<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html lang="en">

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>LCOV - coverage_clean.info - 13/bits/stl_uninitialized.h</title>
  <link rel="stylesheet" type="text/css" href="../../gcov.css">
</head>

<body>

          <table width="100%" border=0 cellspacing=0 cellpadding=0>
            <tr><td class="title">LCOV - code coverage report</td></tr>
            <tr><td class="ruler"><img src="../../glass.png" width=3 height=3 alt=""></td></tr>

            <tr>
              <td width="100%">
                <table cellpadding=1 border=0 width="100%">
          <tr>
            <td width="10%" class="headerItem">Current view:</td>
            <td width="10%" class="headerValue"><a href="../../index.html">top level</a> - <a href="index.html">13/bits</a> - stl_uninitialized.h<span style="font-size: 80%;"> (source / <a href="stl_uninitialized.h.func-c.html">functions</a>)</span></td>
            <td width="5%"></td>
            <td width="5%"></td>
            <td width="5%" class="headerCovTableHead">Coverage</td>
            <td width="5%" class="headerCovTableHead" title="Covered + Uncovered code">Total</td>
            <td width="5%" class="headerCovTableHead" title="Exercised code only">Hit</td>
          </tr>
          <tr>
            <td class="headerItem">Test:</td>
            <td class="headerValue">coverage_clean.info</td>
            <td></td>
            <td class="headerItem">Lines:</td>
            <td class="headerCovTableEntryHi">100.0&nbsp;%</td>
            <td class="headerCovTableEntry">12</td>
            <td class="headerCovTableEntry">12</td>
          </tr>
          <tr>
            <td class="headerItem">Test Date:</td>
            <td class="headerValue">2025-11-25 04:45:29</td>
            <td></td>
            <td class="headerItem">Functions:</td>
            <td class="headerCovTableEntryLo">55.6&nbsp;%</td>
            <td class="headerCovTableEntry">9</td>
            <td class="headerCovTableEntry">5</td>
          </tr>
                  <tr><td><img src="../../glass.png" width=3 height=3 alt=""></td></tr>
                </table>
              </td>
            </tr>

            <tr><td class="ruler"><img src="../../glass.png" width=3 height=3 alt=""></td></tr>
          </table>

          <table cellpadding=0 cellspacing=0 border=0>
            <tr>
              <td><br></td>
            </tr>
            <tr>
              <td>
<pre class="sourceHeading">            Line data    Source code</pre>
<pre class="source">
<span id="L1"><span class="lineNum">       1</span>              : // Raw memory manipulators -*- C++ -*-</span>
<span id="L2"><span class="lineNum">       2</span>              : </span>
<span id="L3"><span class="lineNum">       3</span>              : // Copyright (C) 2001-2023 Free Software Foundation, Inc.</span>
<span id="L4"><span class="lineNum">       4</span>              : //</span>
<span id="L5"><span class="lineNum">       5</span>              : // This file is part of the GNU ISO C++ Library.  This library is free</span>
<span id="L6"><span class="lineNum">       6</span>              : // software; you can redistribute it and/or modify it under the</span>
<span id="L7"><span class="lineNum">       7</span>              : // terms of the GNU General Public License as published by the</span>
<span id="L8"><span class="lineNum">       8</span>              : // Free Software Foundation; either version 3, or (at your option)</span>
<span id="L9"><span class="lineNum">       9</span>              : // any later version.</span>
<span id="L10"><span class="lineNum">      10</span>              : </span>
<span id="L11"><span class="lineNum">      11</span>              : // This library is distributed in the hope that it will be useful,</span>
<span id="L12"><span class="lineNum">      12</span>              : // but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<span id="L13"><span class="lineNum">      13</span>              : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
<span id="L14"><span class="lineNum">      14</span>              : // GNU General Public License for more details.</span>
<span id="L15"><span class="lineNum">      15</span>              : </span>
<span id="L16"><span class="lineNum">      16</span>              : // Under Section 7 of GPL version 3, you are granted additional</span>
<span id="L17"><span class="lineNum">      17</span>              : // permissions described in the GCC Runtime Library Exception, version</span>
<span id="L18"><span class="lineNum">      18</span>              : // 3.1, as published by the Free Software Foundation.</span>
<span id="L19"><span class="lineNum">      19</span>              : </span>
<span id="L20"><span class="lineNum">      20</span>              : // You should have received a copy of the GNU General Public License and</span>
<span id="L21"><span class="lineNum">      21</span>              : // a copy of the GCC Runtime Library Exception along with this program;</span>
<span id="L22"><span class="lineNum">      22</span>              : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see</span>
<span id="L23"><span class="lineNum">      23</span>              : // &lt;http://www.gnu.org/licenses/&gt;.</span>
<span id="L24"><span class="lineNum">      24</span>              : </span>
<span id="L25"><span class="lineNum">      25</span>              : /*</span>
<span id="L26"><span class="lineNum">      26</span>              :  *</span>
<span id="L27"><span class="lineNum">      27</span>              :  * Copyright (c) 1994</span>
<span id="L28"><span class="lineNum">      28</span>              :  * Hewlett-Packard Company</span>
<span id="L29"><span class="lineNum">      29</span>              :  *</span>
<span id="L30"><span class="lineNum">      30</span>              :  * Permission to use, copy, modify, distribute and sell this software</span>
<span id="L31"><span class="lineNum">      31</span>              :  * and its documentation for any purpose is hereby granted without fee,</span>
<span id="L32"><span class="lineNum">      32</span>              :  * provided that the above copyright notice appear in all copies and</span>
<span id="L33"><span class="lineNum">      33</span>              :  * that both that copyright notice and this permission notice appear</span>
<span id="L34"><span class="lineNum">      34</span>              :  * in supporting documentation.  Hewlett-Packard Company makes no</span>
<span id="L35"><span class="lineNum">      35</span>              :  * representations about the suitability of this software for any</span>
<span id="L36"><span class="lineNum">      36</span>              :  * purpose.  It is provided &quot;as is&quot; without express or implied warranty.</span>
<span id="L37"><span class="lineNum">      37</span>              :  *</span>
<span id="L38"><span class="lineNum">      38</span>              :  *</span>
<span id="L39"><span class="lineNum">      39</span>              :  * Copyright (c) 1996,1997</span>
<span id="L40"><span class="lineNum">      40</span>              :  * Silicon Graphics Computer Systems, Inc.</span>
<span id="L41"><span class="lineNum">      41</span>              :  *</span>
<span id="L42"><span class="lineNum">      42</span>              :  * Permission to use, copy, modify, distribute and sell this software</span>
<span id="L43"><span class="lineNum">      43</span>              :  * and its documentation for any purpose is hereby granted without fee,</span>
<span id="L44"><span class="lineNum">      44</span>              :  * provided that the above copyright notice appear in all copies and</span>
<span id="L45"><span class="lineNum">      45</span>              :  * that both that copyright notice and this permission notice appear</span>
<span id="L46"><span class="lineNum">      46</span>              :  * in supporting documentation.  Silicon Graphics makes no</span>
<span id="L47"><span class="lineNum">      47</span>              :  * representations about the suitability of this software for any</span>
<span id="L48"><span class="lineNum">      48</span>              :  * purpose.  It is provided &quot;as is&quot; without express or implied warranty.</span>
<span id="L49"><span class="lineNum">      49</span>              :  */</span>
<span id="L50"><span class="lineNum">      50</span>              : </span>
<span id="L51"><span class="lineNum">      51</span>              : /** @file bits/stl_uninitialized.h</span>
<span id="L52"><span class="lineNum">      52</span>              :  *  This is an internal header file, included by other library headers.</span>
<span id="L53"><span class="lineNum">      53</span>              :  *  Do not attempt to use it directly. @headername{memory}</span>
<span id="L54"><span class="lineNum">      54</span>              :  */</span>
<span id="L55"><span class="lineNum">      55</span>              : </span>
<span id="L56"><span class="lineNum">      56</span>              : #ifndef _STL_UNINITIALIZED_H</span>
<span id="L57"><span class="lineNum">      57</span>              : #define _STL_UNINITIALIZED_H 1</span>
<span id="L58"><span class="lineNum">      58</span>              : </span>
<span id="L59"><span class="lineNum">      59</span>              : #if __cplusplus &gt;= 201103L</span>
<span id="L60"><span class="lineNum">      60</span>              : #include &lt;type_traits&gt;</span>
<span id="L61"><span class="lineNum">      61</span>              : #endif</span>
<span id="L62"><span class="lineNum">      62</span>              : </span>
<span id="L63"><span class="lineNum">      63</span>              : #include &lt;bits/stl_algobase.h&gt;    // copy</span>
<span id="L64"><span class="lineNum">      64</span>              : #include &lt;ext/alloc_traits.h&gt;     // __alloc_traits</span>
<span id="L65"><span class="lineNum">      65</span>              : </span>
<span id="L66"><span class="lineNum">      66</span>              : #if __cplusplus &gt;= 201703L</span>
<span id="L67"><span class="lineNum">      67</span>              : #include &lt;bits/stl_pair.h&gt;</span>
<span id="L68"><span class="lineNum">      68</span>              : #endif</span>
<span id="L69"><span class="lineNum">      69</span>              : </span>
<span id="L70"><span class="lineNum">      70</span>              : namespace std _GLIBCXX_VISIBILITY(default)</span>
<span id="L71"><span class="lineNum">      71</span>              : {</span>
<span id="L72"><span class="lineNum">      72</span>              : _GLIBCXX_BEGIN_NAMESPACE_VERSION</span>
<span id="L73"><span class="lineNum">      73</span>              : </span>
<span id="L74"><span class="lineNum">      74</span>              :   /** @addtogroup memory</span>
<span id="L75"><span class="lineNum">      75</span>              :    *  @{</span>
<span id="L76"><span class="lineNum">      76</span>              :    */</span>
<span id="L77"><span class="lineNum">      77</span>              : </span>
<span id="L78"><span class="lineNum">      78</span>              :   /// @cond undocumented</span>
<span id="L79"><span class="lineNum">      79</span>              : </span>
<span id="L80"><span class="lineNum">      80</span>              : #if __cplusplus &gt;= 201103L</span>
<span id="L81"><span class="lineNum">      81</span>              :   template&lt;typename _ValueType, typename _Tp&gt;</span>
<span id="L82"><span class="lineNum">      82</span>              :     constexpr bool</span>
<span id="L83"><span class="lineNum">      83</span>              :     __check_constructible()</span>
<span id="L84"><span class="lineNum">      84</span>              :     {</span>
<span id="L85"><span class="lineNum">      85</span>              :       // Trivial types can have deleted constructors, but std::copy etc.</span>
<span id="L86"><span class="lineNum">      86</span>              :       // only use assignment (or memmove) not construction, so we need an</span>
<span id="L87"><span class="lineNum">      87</span>              :       // explicit check that construction from _Tp is actually valid,</span>
<span id="L88"><span class="lineNum">      88</span>              :       // otherwise some ill-formed uses of std::uninitialized_xxx would</span>
<span id="L89"><span class="lineNum">      89</span>              :       // compile without errors. This gives a nice clear error message.</span>
<span id="L90"><span class="lineNum">      90</span>              :       static_assert(is_constructible&lt;_ValueType, _Tp&gt;::value,</span>
<span id="L91"><span class="lineNum">      91</span>              :           &quot;result type must be constructible from input type&quot;);</span>
<span id="L92"><span class="lineNum">      92</span>              : </span>
<span id="L93"><span class="lineNum">      93</span>              :       return true;</span>
<span id="L94"><span class="lineNum">      94</span>              :     }</span>
<span id="L95"><span class="lineNum">      95</span>              : </span>
<span id="L96"><span class="lineNum">      96</span>              : // If the type is trivial we don't need to construct it, just assign to it.</span>
<span id="L97"><span class="lineNum">      97</span>              : // But trivial types can still have deleted or inaccessible assignment,</span>
<span id="L98"><span class="lineNum">      98</span>              : // so don't try to use std::copy or std::fill etc. if we can't assign.</span>
<span id="L99"><span class="lineNum">      99</span>              : # define _GLIBCXX_USE_ASSIGN_FOR_INIT(T, U) \</span>
<span id="L100"><span class="lineNum">     100</span>              :     __is_trivial(T) &amp;&amp; __is_assignable(T&amp;, U) \</span>
<span id="L101"><span class="lineNum">     101</span>              :     &amp;&amp; std::__check_constructible&lt;T, U&gt;()</span>
<span id="L102"><span class="lineNum">     102</span>              : #else</span>
<span id="L103"><span class="lineNum">     103</span>              : // No need to check if is_constructible&lt;T, U&gt; for C++98. Trivial types have</span>
<span id="L104"><span class="lineNum">     104</span>              : // no user-declared constructors, so if the assignment is valid, construction</span>
<span id="L105"><span class="lineNum">     105</span>              : // should be too.</span>
<span id="L106"><span class="lineNum">     106</span>              : # define _GLIBCXX_USE_ASSIGN_FOR_INIT(T, U) \</span>
<span id="L107"><span class="lineNum">     107</span>              :     __is_trivial(T) &amp;&amp; __is_assignable(T&amp;, U)</span>
<span id="L108"><span class="lineNum">     108</span>              : #endif</span>
<span id="L109"><span class="lineNum">     109</span>              : </span>
<span id="L110"><span class="lineNum">     110</span>              :   template&lt;typename _InputIterator, typename _ForwardIterator&gt;</span>
<span id="L111"><span class="lineNum">     111</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L112"><span class="lineNum">     112</span>              :     _ForwardIterator</span>
<span id="L113"><span class="lineNum">     113</span>              :     __do_uninit_copy(_InputIterator __first, _InputIterator __last,</span>
<span id="L114"><span class="lineNum">     114</span>              :                      _ForwardIterator __result)</span>
<span id="L115"><span class="lineNum">     115</span>              :     {</span>
<span id="L116"><span class="lineNum">     116</span>              :       _ForwardIterator __cur = __result;</span>
<span id="L117"><span class="lineNum">     117</span>              :       __try</span>
<span id="L118"><span class="lineNum">     118</span>              :         {</span>
<span id="L119"><span class="lineNum">     119</span>              :           for (; __first != __last; ++__first, (void)++__cur)</span>
<span id="L120"><span class="lineNum">     120</span>              :             std::_Construct(std::__addressof(*__cur), *__first);</span>
<span id="L121"><span class="lineNum">     121</span>              :           return __cur;</span>
<span id="L122"><span class="lineNum">     122</span>              :         }</span>
<span id="L123"><span class="lineNum">     123</span>              :       __catch(...)</span>
<span id="L124"><span class="lineNum">     124</span>              :         {</span>
<span id="L125"><span class="lineNum">     125</span>              :           std::_Destroy(__result, __cur);</span>
<span id="L126"><span class="lineNum">     126</span>              :           __throw_exception_again;</span>
<span id="L127"><span class="lineNum">     127</span>              :         }</span>
<span id="L128"><span class="lineNum">     128</span>              :     }</span>
<span id="L129"><span class="lineNum">     129</span>              : </span>
<span id="L130"><span class="lineNum">     130</span>              :   template&lt;bool _TrivialValueTypes&gt;</span>
<span id="L131"><span class="lineNum">     131</span>              :     struct __uninitialized_copy</span>
<span id="L132"><span class="lineNum">     132</span>              :     {</span>
<span id="L133"><span class="lineNum">     133</span>              :       template&lt;typename _InputIterator, typename _ForwardIterator&gt;</span>
<span id="L134"><span class="lineNum">     134</span>              :         static _ForwardIterator</span>
<span id="L135"><span class="lineNum">     135</span>              :         __uninit_copy(_InputIterator __first, _InputIterator __last,</span>
<span id="L136"><span class="lineNum">     136</span>              :                       _ForwardIterator __result)</span>
<span id="L137"><span class="lineNum">     137</span>              :         { return std::__do_uninit_copy(__first, __last, __result); }</span>
<span id="L138"><span class="lineNum">     138</span>              :     };</span>
<span id="L139"><span class="lineNum">     139</span>              : </span>
<span id="L140"><span class="lineNum">     140</span>              :   template&lt;&gt;</span>
<span id="L141"><span class="lineNum">     141</span>              :     struct __uninitialized_copy&lt;true&gt;</span>
<span id="L142"><span class="lineNum">     142</span>              :     {</span>
<span id="L143"><span class="lineNum">     143</span>              :       template&lt;typename _InputIterator, typename _ForwardIterator&gt;</span>
<span id="L144"><span class="lineNum">     144</span>              :         static _ForwardIterator</span>
<span id="L145"><span class="lineNum">     145</span>              :         __uninit_copy(_InputIterator __first, _InputIterator __last,</span>
<span id="L146"><span class="lineNum">     146</span>              :                       _ForwardIterator __result)</span>
<span id="L147"><span class="lineNum">     147</span>              :         { return std::copy(__first, __last, __result); }</span>
<span id="L148"><span class="lineNum">     148</span>              :     };</span>
<span id="L149"><span class="lineNum">     149</span>              : </span>
<span id="L150"><span class="lineNum">     150</span>              :   /// @endcond</span>
<span id="L151"><span class="lineNum">     151</span>              : </span>
<span id="L152"><span class="lineNum">     152</span>              :   /**</span>
<span id="L153"><span class="lineNum">     153</span>              :    *  @brief Copies the range [first,last) into result.</span>
<span id="L154"><span class="lineNum">     154</span>              :    *  @param  __first  An input iterator.</span>
<span id="L155"><span class="lineNum">     155</span>              :    *  @param  __last   An input iterator.</span>
<span id="L156"><span class="lineNum">     156</span>              :    *  @param  __result An output iterator.</span>
<span id="L157"><span class="lineNum">     157</span>              :    *  @return   __result + (__first - __last)</span>
<span id="L158"><span class="lineNum">     158</span>              :    *</span>
<span id="L159"><span class="lineNum">     159</span>              :    *  Like copy(), but does not require an initialized output range.</span>
<span id="L160"><span class="lineNum">     160</span>              :   */</span>
<span id="L161"><span class="lineNum">     161</span>              :   template&lt;typename _InputIterator, typename _ForwardIterator&gt;</span>
<span id="L162"><span class="lineNum">     162</span>              :     inline _ForwardIterator</span>
<span id="L163"><span class="lineNum">     163</span>              :     uninitialized_copy(_InputIterator __first, _InputIterator __last,</span>
<span id="L164"><span class="lineNum">     164</span>              :                        _ForwardIterator __result)</span>
<span id="L165"><span class="lineNum">     165</span>              :     {</span>
<span id="L166"><span class="lineNum">     166</span>              :       typedef typename iterator_traits&lt;_InputIterator&gt;::value_type</span>
<span id="L167"><span class="lineNum">     167</span>              :         _ValueType1;</span>
<span id="L168"><span class="lineNum">     168</span>              :       typedef typename iterator_traits&lt;_ForwardIterator&gt;::value_type</span>
<span id="L169"><span class="lineNum">     169</span>              :         _ValueType2;</span>
<span id="L170"><span class="lineNum">     170</span>              : </span>
<span id="L171"><span class="lineNum">     171</span>              :       // _ValueType1 must be trivially-copyable to use memmove, so don't</span>
<span id="L172"><span class="lineNum">     172</span>              :       // bother optimizing to std::copy if it isn't.</span>
<span id="L173"><span class="lineNum">     173</span>              :       // XXX Unnecessary because std::copy would check it anyway?</span>
<span id="L174"><span class="lineNum">     174</span>              :       const bool __can_memmove = __is_trivial(_ValueType1);</span>
<span id="L175"><span class="lineNum">     175</span>              : </span>
<span id="L176"><span class="lineNum">     176</span>              : #if __cplusplus &lt; 201103L</span>
<span id="L177"><span class="lineNum">     177</span>              :       typedef typename iterator_traits&lt;_InputIterator&gt;::reference _From;</span>
<span id="L178"><span class="lineNum">     178</span>              : #else</span>
<span id="L179"><span class="lineNum">     179</span>              :       using _From = decltype(*__first);</span>
<span id="L180"><span class="lineNum">     180</span>              : #endif</span>
<span id="L181"><span class="lineNum">     181</span>              :       const bool __assignable</span>
<span id="L182"><span class="lineNum">     182</span>              :         = _GLIBCXX_USE_ASSIGN_FOR_INIT(_ValueType2, _From);</span>
<span id="L183"><span class="lineNum">     183</span>              : </span>
<span id="L184"><span class="lineNum">     184</span>              :       return std::__uninitialized_copy&lt;__can_memmove &amp;&amp; __assignable&gt;::</span>
<span id="L185"><span class="lineNum">     185</span>              :         __uninit_copy(__first, __last, __result);</span>
<span id="L186"><span class="lineNum">     186</span>              :     }</span>
<span id="L187"><span class="lineNum">     187</span>              : </span>
<span id="L188"><span class="lineNum">     188</span>              :   /// @cond undocumented</span>
<span id="L189"><span class="lineNum">     189</span>              : </span>
<span id="L190"><span class="lineNum">     190</span>              :   template&lt;typename _ForwardIterator, typename _Tp&gt;</span>
<span id="L191"><span class="lineNum">     191</span>              :     _GLIBCXX20_CONSTEXPR void</span>
<span id="L192"><span class="lineNum">     192</span>              :     __do_uninit_fill(_ForwardIterator __first, _ForwardIterator __last,</span>
<span id="L193"><span class="lineNum">     193</span>              :                      const _Tp&amp; __x)</span>
<span id="L194"><span class="lineNum">     194</span>              :     {</span>
<span id="L195"><span class="lineNum">     195</span>              :       _ForwardIterator __cur = __first;</span>
<span id="L196"><span class="lineNum">     196</span>              :       __try</span>
<span id="L197"><span class="lineNum">     197</span>              :         {</span>
<span id="L198"><span class="lineNum">     198</span>              :           for (; __cur != __last; ++__cur)</span>
<span id="L199"><span class="lineNum">     199</span>              :             std::_Construct(std::__addressof(*__cur), __x);</span>
<span id="L200"><span class="lineNum">     200</span>              :         }</span>
<span id="L201"><span class="lineNum">     201</span>              :       __catch(...)</span>
<span id="L202"><span class="lineNum">     202</span>              :         {</span>
<span id="L203"><span class="lineNum">     203</span>              :           std::_Destroy(__first, __cur);</span>
<span id="L204"><span class="lineNum">     204</span>              :           __throw_exception_again;</span>
<span id="L205"><span class="lineNum">     205</span>              :         }</span>
<span id="L206"><span class="lineNum">     206</span>              :     }</span>
<span id="L207"><span class="lineNum">     207</span>              : </span>
<span id="L208"><span class="lineNum">     208</span>              :   template&lt;bool _TrivialValueType&gt;</span>
<span id="L209"><span class="lineNum">     209</span>              :     struct __uninitialized_fill</span>
<span id="L210"><span class="lineNum">     210</span>              :     {</span>
<span id="L211"><span class="lineNum">     211</span>              :       template&lt;typename _ForwardIterator, typename _Tp&gt;</span>
<span id="L212"><span class="lineNum">     212</span>              :         static void</span>
<span id="L213"><span class="lineNum">     213</span>              :         __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,</span>
<span id="L214"><span class="lineNum">     214</span>              :                       const _Tp&amp; __x)</span>
<span id="L215"><span class="lineNum">     215</span>              :         { std::__do_uninit_fill(__first, __last, __x); }</span>
<span id="L216"><span class="lineNum">     216</span>              :     };</span>
<span id="L217"><span class="lineNum">     217</span>              : </span>
<span id="L218"><span class="lineNum">     218</span>              :   template&lt;&gt;</span>
<span id="L219"><span class="lineNum">     219</span>              :     struct __uninitialized_fill&lt;true&gt;</span>
<span id="L220"><span class="lineNum">     220</span>              :     {</span>
<span id="L221"><span class="lineNum">     221</span>              :       template&lt;typename _ForwardIterator, typename _Tp&gt;</span>
<span id="L222"><span class="lineNum">     222</span>              :         static void</span>
<span id="L223"><span class="lineNum">     223</span>              :         __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,</span>
<span id="L224"><span class="lineNum">     224</span>              :                       const _Tp&amp; __x)</span>
<span id="L225"><span class="lineNum">     225</span>              :         { std::fill(__first, __last, __x); }</span>
<span id="L226"><span class="lineNum">     226</span>              :     };</span>
<span id="L227"><span class="lineNum">     227</span>              : </span>
<span id="L228"><span class="lineNum">     228</span>              :   /// @endcond</span>
<span id="L229"><span class="lineNum">     229</span>              : </span>
<span id="L230"><span class="lineNum">     230</span>              :   /**</span>
<span id="L231"><span class="lineNum">     231</span>              :    *  @brief Copies the value x into the range [first,last).</span>
<span id="L232"><span class="lineNum">     232</span>              :    *  @param  __first  An input iterator.</span>
<span id="L233"><span class="lineNum">     233</span>              :    *  @param  __last   An input iterator.</span>
<span id="L234"><span class="lineNum">     234</span>              :    *  @param  __x      The source value.</span>
<span id="L235"><span class="lineNum">     235</span>              :    *  @return   Nothing.</span>
<span id="L236"><span class="lineNum">     236</span>              :    *</span>
<span id="L237"><span class="lineNum">     237</span>              :    *  Like fill(), but does not require an initialized output range.</span>
<span id="L238"><span class="lineNum">     238</span>              :   */</span>
<span id="L239"><span class="lineNum">     239</span>              :   template&lt;typename _ForwardIterator, typename _Tp&gt;</span>
<span id="L240"><span class="lineNum">     240</span>              :     inline void</span>
<span id="L241"><span class="lineNum">     241</span>              :     uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,</span>
<span id="L242"><span class="lineNum">     242</span>              :                        const _Tp&amp; __x)</span>
<span id="L243"><span class="lineNum">     243</span>              :     {</span>
<span id="L244"><span class="lineNum">     244</span>              :       typedef typename iterator_traits&lt;_ForwardIterator&gt;::value_type</span>
<span id="L245"><span class="lineNum">     245</span>              :         _ValueType;</span>
<span id="L246"><span class="lineNum">     246</span>              : </span>
<span id="L247"><span class="lineNum">     247</span>              :       // Trivial types do not need a constructor to begin their lifetime,</span>
<span id="L248"><span class="lineNum">     248</span>              :       // so try to use std::fill to benefit from its memset optimization.</span>
<span id="L249"><span class="lineNum">     249</span>              :       const bool __can_fill</span>
<span id="L250"><span class="lineNum">     250</span>              :         = _GLIBCXX_USE_ASSIGN_FOR_INIT(_ValueType, const _Tp&amp;);</span>
<span id="L251"><span class="lineNum">     251</span>              : </span>
<span id="L252"><span class="lineNum">     252</span>              :       std::__uninitialized_fill&lt;__can_fill&gt;::</span>
<span id="L253"><span class="lineNum">     253</span>              :         __uninit_fill(__first, __last, __x);</span>
<span id="L254"><span class="lineNum">     254</span>              :     }</span>
<span id="L255"><span class="lineNum">     255</span>              : </span>
<span id="L256"><span class="lineNum">     256</span>              :   /// @cond undocumented</span>
<span id="L257"><span class="lineNum">     257</span>              : </span>
<span id="L258"><span class="lineNum">     258</span>              :   template&lt;typename _ForwardIterator, typename _Size, typename _Tp&gt;</span>
<span id="L259"><span class="lineNum">     259</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L260"><span class="lineNum">     260</span>              :     _ForwardIterator</span>
<span id="L261"><span class="lineNum">     261</span>              :     __do_uninit_fill_n(_ForwardIterator __first, _Size __n, const _Tp&amp; __x)</span>
<span id="L262"><span class="lineNum">     262</span>              :     {</span>
<span id="L263"><span class="lineNum">     263</span>              :       _ForwardIterator __cur = __first;</span>
<span id="L264"><span class="lineNum">     264</span>              :       __try</span>
<span id="L265"><span class="lineNum">     265</span>              :         {</span>
<span id="L266"><span class="lineNum">     266</span>              :           for (; __n &gt; 0; --__n, (void) ++__cur)</span>
<span id="L267"><span class="lineNum">     267</span>              :             std::_Construct(std::__addressof(*__cur), __x);</span>
<span id="L268"><span class="lineNum">     268</span>              :           return __cur;</span>
<span id="L269"><span class="lineNum">     269</span>              :         }</span>
<span id="L270"><span class="lineNum">     270</span>              :       __catch(...)</span>
<span id="L271"><span class="lineNum">     271</span>              :         {</span>
<span id="L272"><span class="lineNum">     272</span>              :           std::_Destroy(__first, __cur);</span>
<span id="L273"><span class="lineNum">     273</span>              :           __throw_exception_again;</span>
<span id="L274"><span class="lineNum">     274</span>              :         }</span>
<span id="L275"><span class="lineNum">     275</span>              :     }</span>
<span id="L276"><span class="lineNum">     276</span>              : </span>
<span id="L277"><span class="lineNum">     277</span>              :   template&lt;bool _TrivialValueType&gt;</span>
<span id="L278"><span class="lineNum">     278</span>              :     struct __uninitialized_fill_n</span>
<span id="L279"><span class="lineNum">     279</span>              :     {</span>
<span id="L280"><span class="lineNum">     280</span>              :       template&lt;typename _ForwardIterator, typename _Size, typename _Tp&gt;</span>
<span id="L281"><span class="lineNum">     281</span>              :         static _ForwardIterator</span>
<span id="L282"><span class="lineNum">     282</span>              :         __uninit_fill_n(_ForwardIterator __first, _Size __n,</span>
<span id="L283"><span class="lineNum">     283</span>              :                         const _Tp&amp; __x)</span>
<span id="L284"><span class="lineNum">     284</span>              :         { return std::__do_uninit_fill_n(__first, __n, __x); }</span>
<span id="L285"><span class="lineNum">     285</span>              :     };</span>
<span id="L286"><span class="lineNum">     286</span>              : </span>
<span id="L287"><span class="lineNum">     287</span>              :   template&lt;&gt;</span>
<span id="L288"><span class="lineNum">     288</span>              :     struct __uninitialized_fill_n&lt;true&gt;</span>
<span id="L289"><span class="lineNum">     289</span>              :     {</span>
<span id="L290"><span class="lineNum">     290</span>              :       template&lt;typename _ForwardIterator, typename _Size, typename _Tp&gt;</span>
<span id="L291"><span class="lineNum">     291</span>              :         static _ForwardIterator</span>
<span id="L292"><span class="lineNum">     292</span>              :         __uninit_fill_n(_ForwardIterator __first, _Size __n,</span>
<span id="L293"><span class="lineNum">     293</span>              :                         const _Tp&amp; __x)</span>
<span id="L294"><span class="lineNum">     294</span>              :         { return std::fill_n(__first, __n, __x); }</span>
<span id="L295"><span class="lineNum">     295</span>              :     };</span>
<span id="L296"><span class="lineNum">     296</span>              : </span>
<span id="L297"><span class="lineNum">     297</span>              :   /// @endcond</span>
<span id="L298"><span class="lineNum">     298</span>              : </span>
<span id="L299"><span class="lineNum">     299</span>              :    // _GLIBCXX_RESOLVE_LIB_DEFECTS</span>
<span id="L300"><span class="lineNum">     300</span>              :    // DR 1339. uninitialized_fill_n should return the end of its range</span>
<span id="L301"><span class="lineNum">     301</span>              :   /**</span>
<span id="L302"><span class="lineNum">     302</span>              :    *  @brief Copies the value x into the range [first,first+n).</span>
<span id="L303"><span class="lineNum">     303</span>              :    *  @param  __first  An input iterator.</span>
<span id="L304"><span class="lineNum">     304</span>              :    *  @param  __n      The number of copies to make.</span>
<span id="L305"><span class="lineNum">     305</span>              :    *  @param  __x      The source value.</span>
<span id="L306"><span class="lineNum">     306</span>              :    *  @return   Nothing.</span>
<span id="L307"><span class="lineNum">     307</span>              :    *</span>
<span id="L308"><span class="lineNum">     308</span>              :    *  Like fill_n(), but does not require an initialized output range.</span>
<span id="L309"><span class="lineNum">     309</span>              :   */</span>
<span id="L310"><span class="lineNum">     310</span>              :   template&lt;typename _ForwardIterator, typename _Size, typename _Tp&gt;</span>
<span id="L311"><span class="lineNum">     311</span>              :     inline _ForwardIterator</span>
<span id="L312"><span class="lineNum">     312</span>              :     uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp&amp; __x)</span>
<span id="L313"><span class="lineNum">     313</span>              :     {</span>
<span id="L314"><span class="lineNum">     314</span>              :       typedef typename iterator_traits&lt;_ForwardIterator&gt;::value_type</span>
<span id="L315"><span class="lineNum">     315</span>              :         _ValueType;</span>
<span id="L316"><span class="lineNum">     316</span>              : </span>
<span id="L317"><span class="lineNum">     317</span>              :       // Trivial types do not need a constructor to begin their lifetime,</span>
<span id="L318"><span class="lineNum">     318</span>              :       // so try to use std::fill_n to benefit from its optimizations.</span>
<span id="L319"><span class="lineNum">     319</span>              :       const bool __can_fill</span>
<span id="L320"><span class="lineNum">     320</span>              :         = _GLIBCXX_USE_ASSIGN_FOR_INIT(_ValueType, const _Tp&amp;)</span>
<span id="L321"><span class="lineNum">     321</span>              :       // For arbitrary class types and floating point types we can't assume</span>
<span id="L322"><span class="lineNum">     322</span>              :       // that __n &gt; 0 and std::__size_to_integer(__n) &gt; 0 are equivalent,</span>
<span id="L323"><span class="lineNum">     323</span>              :       // so only use std::fill_n when _Size is already an integral type.</span>
<span id="L324"><span class="lineNum">     324</span>              :         &amp;&amp; __is_integer&lt;_Size&gt;::__value;</span>
<span id="L325"><span class="lineNum">     325</span>              : </span>
<span id="L326"><span class="lineNum">     326</span>              :       return __uninitialized_fill_n&lt;__can_fill&gt;::</span>
<span id="L327"><span class="lineNum">     327</span>              :         __uninit_fill_n(__first, __n, __x);</span>
<span id="L328"><span class="lineNum">     328</span>              :     }</span>
<span id="L329"><span class="lineNum">     329</span>              : </span>
<span id="L330"><span class="lineNum">     330</span>              : #undef _GLIBCXX_USE_ASSIGN_FOR_INIT</span>
<span id="L331"><span class="lineNum">     331</span>              : </span>
<span id="L332"><span class="lineNum">     332</span>              :   /// @cond undocumented</span>
<span id="L333"><span class="lineNum">     333</span>              : </span>
<span id="L334"><span class="lineNum">     334</span>              :   // Extensions: versions of uninitialized_copy, uninitialized_fill,</span>
<span id="L335"><span class="lineNum">     335</span>              :   //  and uninitialized_fill_n that take an allocator parameter.</span>
<span id="L336"><span class="lineNum">     336</span>              :   //  We dispatch back to the standard versions when we're given the</span>
<span id="L337"><span class="lineNum">     337</span>              :   //  default allocator.  For nondefault allocators we do not use</span>
<span id="L338"><span class="lineNum">     338</span>              :   //  any of the POD optimizations.</span>
<span id="L339"><span class="lineNum">     339</span>              : </span>
<span id="L340"><span class="lineNum">     340</span>              :   template&lt;typename _InputIterator, typename _ForwardIterator,</span>
<span id="L341"><span class="lineNum">     341</span>              :            typename _Allocator&gt;</span>
<span id="L342"><span class="lineNum">     342</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L343"><span class="lineNum">     343</span>              :     _ForwardIterator</span>
<span id="L344"><span class="lineNum">     344</span>              :     __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,</span>
<span id="L345"><span class="lineNum">     345</span>              :                            _ForwardIterator __result, _Allocator&amp; __alloc)</span>
<span id="L346"><span class="lineNum">     346</span>              :     {</span>
<span id="L347"><span class="lineNum">     347</span>              :       _ForwardIterator __cur = __result;</span>
<span id="L348"><span class="lineNum">     348</span>              :       __try</span>
<span id="L349"><span class="lineNum">     349</span>              :         {</span>
<span id="L350"><span class="lineNum">     350</span>              :           typedef __gnu_cxx::__alloc_traits&lt;_Allocator&gt; __traits;</span>
<span id="L351"><span class="lineNum">     351</span>              :           for (; __first != __last; ++__first, (void)++__cur)</span>
<span id="L352"><span class="lineNum">     352</span>              :             __traits::construct(__alloc, std::__addressof(*__cur), *__first);</span>
<span id="L353"><span class="lineNum">     353</span>              :           return __cur;</span>
<span id="L354"><span class="lineNum">     354</span>              :         }</span>
<span id="L355"><span class="lineNum">     355</span>              :       __catch(...)</span>
<span id="L356"><span class="lineNum">     356</span>              :         {</span>
<span id="L357"><span class="lineNum">     357</span>              :           std::_Destroy(__result, __cur, __alloc);</span>
<span id="L358"><span class="lineNum">     358</span>              :           __throw_exception_again;</span>
<span id="L359"><span class="lineNum">     359</span>              :         }</span>
<span id="L360"><span class="lineNum">     360</span>              :     }</span>
<span id="L361"><span class="lineNum">     361</span>              : </span>
<span id="L362"><span class="lineNum">     362</span>              : #if _GLIBCXX_HOSTED</span>
<span id="L363"><span class="lineNum">     363</span>              :   template&lt;typename _InputIterator, typename _ForwardIterator, typename _Tp&gt;</span>
<span id="L364"><span class="lineNum">     364</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L365"><span class="lineNum">     365</span>              :     inline _ForwardIterator</span>
<span id="L366"><span class="lineNum">     366</span>              :     __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,</span>
<span id="L367"><span class="lineNum">     367</span>              :                            _ForwardIterator __result, allocator&lt;_Tp&gt;&amp;)</span>
<span id="L368"><span class="lineNum">     368</span>              :     {</span>
<span id="L369"><span class="lineNum">     369</span>              : #ifdef __cpp_lib_is_constant_evaluated</span>
<span id="L370"><span class="lineNum">     370</span>              :       if (std::is_constant_evaluated())</span>
<span id="L371"><span class="lineNum">     371</span>              :         return std::__do_uninit_copy(__first, __last, __result);</span>
<span id="L372"><span class="lineNum">     372</span>              : #endif</span>
<span id="L373"><span class="lineNum">     373</span>              :       return std::uninitialized_copy(__first, __last, __result);</span>
<span id="L374"><span class="lineNum">     374</span>              :     }</span>
<span id="L375"><span class="lineNum">     375</span>              : #endif</span>
<span id="L376"><span class="lineNum">     376</span>              : </span>
<span id="L377"><span class="lineNum">     377</span>              :   template&lt;typename _InputIterator, typename _ForwardIterator,</span>
<span id="L378"><span class="lineNum">     378</span>              :            typename _Allocator&gt;</span>
<span id="L379"><span class="lineNum">     379</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L380"><span class="lineNum">     380</span>              :     inline _ForwardIterator</span>
<span id="L381"><span class="lineNum">     381</span>              :     __uninitialized_move_a(_InputIterator __first, _InputIterator __last,</span>
<span id="L382"><span class="lineNum">     382</span>              :                            _ForwardIterator __result, _Allocator&amp; __alloc)</span>
<span id="L383"><span class="lineNum">     383</span>              :     {</span>
<span id="L384"><span class="lineNum">     384</span>              :       return std::__uninitialized_copy_a(_GLIBCXX_MAKE_MOVE_ITERATOR(__first),</span>
<span id="L385"><span class="lineNum">     385</span>              :                                          _GLIBCXX_MAKE_MOVE_ITERATOR(__last),</span>
<span id="L386"><span class="lineNum">     386</span>              :                                          __result, __alloc);</span>
<span id="L387"><span class="lineNum">     387</span>              :     }</span>
<span id="L388"><span class="lineNum">     388</span>              : </span>
<span id="L389"><span class="lineNum">     389</span>              :   template&lt;typename _InputIterator, typename _ForwardIterator,</span>
<span id="L390"><span class="lineNum">     390</span>              :            typename _Allocator&gt;</span>
<span id="L391"><span class="lineNum">     391</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L392"><span class="lineNum">     392</span>              :     inline _ForwardIterator</span>
<span id="L393"><span class="lineNum">     393</span>              :     __uninitialized_move_if_noexcept_a(_InputIterator __first,</span>
<span id="L394"><span class="lineNum">     394</span>              :                                        _InputIterator __last,</span>
<span id="L395"><span class="lineNum">     395</span>              :                                        _ForwardIterator __result,</span>
<span id="L396"><span class="lineNum">     396</span>              :                                        _Allocator&amp; __alloc)</span>
<span id="L397"><span class="lineNum">     397</span>              :     {</span>
<span id="L398"><span class="lineNum">     398</span>              :       return std::__uninitialized_copy_a</span>
<span id="L399"><span class="lineNum">     399</span>              :         (_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__first),</span>
<span id="L400"><span class="lineNum">     400</span>              :          _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__last), __result, __alloc);</span>
<span id="L401"><span class="lineNum">     401</span>              :     }</span>
<span id="L402"><span class="lineNum">     402</span>              : </span>
<span id="L403"><span class="lineNum">     403</span>              :   template&lt;typename _ForwardIterator, typename _Tp, typename _Allocator&gt;</span>
<span id="L404"><span class="lineNum">     404</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L405"><span class="lineNum">     405</span>              :     void</span>
<span id="L406"><span class="lineNum">     406</span>              :     __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,</span>
<span id="L407"><span class="lineNum">     407</span>              :                            const _Tp&amp; __x, _Allocator&amp; __alloc)</span>
<span id="L408"><span class="lineNum">     408</span>              :     {</span>
<span id="L409"><span class="lineNum">     409</span>              :       _ForwardIterator __cur = __first;</span>
<span id="L410"><span class="lineNum">     410</span>              :       __try</span>
<span id="L411"><span class="lineNum">     411</span>              :         {</span>
<span id="L412"><span class="lineNum">     412</span>              :           typedef __gnu_cxx::__alloc_traits&lt;_Allocator&gt; __traits;</span>
<span id="L413"><span class="lineNum">     413</span>              :           for (; __cur != __last; ++__cur)</span>
<span id="L414"><span class="lineNum">     414</span>              :             __traits::construct(__alloc, std::__addressof(*__cur), __x);</span>
<span id="L415"><span class="lineNum">     415</span>              :         }</span>
<span id="L416"><span class="lineNum">     416</span>              :       __catch(...)</span>
<span id="L417"><span class="lineNum">     417</span>              :         {</span>
<span id="L418"><span class="lineNum">     418</span>              :           std::_Destroy(__first, __cur, __alloc);</span>
<span id="L419"><span class="lineNum">     419</span>              :           __throw_exception_again;</span>
<span id="L420"><span class="lineNum">     420</span>              :         }</span>
<span id="L421"><span class="lineNum">     421</span>              :     }</span>
<span id="L422"><span class="lineNum">     422</span>              : </span>
<span id="L423"><span class="lineNum">     423</span>              : #if _GLIBCXX_HOSTED</span>
<span id="L424"><span class="lineNum">     424</span>              :   template&lt;typename _ForwardIterator, typename _Tp, typename _Tp2&gt;</span>
<span id="L425"><span class="lineNum">     425</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L426"><span class="lineNum">     426</span>              :     inline void</span>
<span id="L427"><span class="lineNum">     427</span>              :     __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,</span>
<span id="L428"><span class="lineNum">     428</span>              :                            const _Tp&amp; __x, allocator&lt;_Tp2&gt;&amp;)</span>
<span id="L429"><span class="lineNum">     429</span>              :     {</span>
<span id="L430"><span class="lineNum">     430</span>              : #ifdef __cpp_lib_is_constant_evaluated</span>
<span id="L431"><span class="lineNum">     431</span>              :       if (std::is_constant_evaluated())</span>
<span id="L432"><span class="lineNum">     432</span>              :         return std::__do_uninit_fill(__first, __last, __x);</span>
<span id="L433"><span class="lineNum">     433</span>              : #endif</span>
<span id="L434"><span class="lineNum">     434</span>              :       std::uninitialized_fill(__first, __last, __x);</span>
<span id="L435"><span class="lineNum">     435</span>              :     }</span>
<span id="L436"><span class="lineNum">     436</span>              : #endif</span>
<span id="L437"><span class="lineNum">     437</span>              : </span>
<span id="L438"><span class="lineNum">     438</span>              :   template&lt;typename _ForwardIterator, typename _Size, typename _Tp,</span>
<span id="L439"><span class="lineNum">     439</span>              :            typename _Allocator&gt;</span>
<span id="L440"><span class="lineNum">     440</span>              :      _GLIBCXX20_CONSTEXPR</span>
<span id="L441"><span class="lineNum">     441</span>              :     _ForwardIterator</span>
<span id="L442"><span class="lineNum">     442</span>              :     __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,</span>
<span id="L443"><span class="lineNum">     443</span>              :                              const _Tp&amp; __x, _Allocator&amp; __alloc)</span>
<span id="L444"><span class="lineNum">     444</span>              :     {</span>
<span id="L445"><span class="lineNum">     445</span>              :       _ForwardIterator __cur = __first;</span>
<span id="L446"><span class="lineNum">     446</span>              :       __try</span>
<span id="L447"><span class="lineNum">     447</span>              :         {</span>
<span id="L448"><span class="lineNum">     448</span>              :           typedef __gnu_cxx::__alloc_traits&lt;_Allocator&gt; __traits;</span>
<span id="L449"><span class="lineNum">     449</span>              :           for (; __n &gt; 0; --__n, (void) ++__cur)</span>
<span id="L450"><span class="lineNum">     450</span>              :             __traits::construct(__alloc, std::__addressof(*__cur), __x);</span>
<span id="L451"><span class="lineNum">     451</span>              :           return __cur;</span>
<span id="L452"><span class="lineNum">     452</span>              :         }</span>
<span id="L453"><span class="lineNum">     453</span>              :       __catch(...)</span>
<span id="L454"><span class="lineNum">     454</span>              :         {</span>
<span id="L455"><span class="lineNum">     455</span>              :           std::_Destroy(__first, __cur, __alloc);</span>
<span id="L456"><span class="lineNum">     456</span>              :           __throw_exception_again;</span>
<span id="L457"><span class="lineNum">     457</span>              :         }</span>
<span id="L458"><span class="lineNum">     458</span>              :     }</span>
<span id="L459"><span class="lineNum">     459</span>              : </span>
<span id="L460"><span class="lineNum">     460</span>              : #if _GLIBCXX_HOSTED</span>
<span id="L461"><span class="lineNum">     461</span>              :   template&lt;typename _ForwardIterator, typename _Size, typename _Tp,</span>
<span id="L462"><span class="lineNum">     462</span>              :            typename _Tp2&gt;</span>
<span id="L463"><span class="lineNum">     463</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L464"><span class="lineNum">     464</span>              :     inline _ForwardIterator</span>
<span id="L465"><span class="lineNum">     465</span>              :     __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,</span>
<span id="L466"><span class="lineNum">     466</span>              :                              const _Tp&amp; __x, allocator&lt;_Tp2&gt;&amp;)</span>
<span id="L467"><span class="lineNum">     467</span>              :     {</span>
<span id="L468"><span class="lineNum">     468</span>              : #ifdef __cpp_lib_is_constant_evaluated</span>
<span id="L469"><span class="lineNum">     469</span>              :       if (std::is_constant_evaluated())</span>
<span id="L470"><span class="lineNum">     470</span>              :         return std::__do_uninit_fill_n(__first, __n, __x);</span>
<span id="L471"><span class="lineNum">     471</span>              : #endif</span>
<span id="L472"><span class="lineNum">     472</span>              :       return std::uninitialized_fill_n(__first, __n, __x);</span>
<span id="L473"><span class="lineNum">     473</span>              :     }</span>
<span id="L474"><span class="lineNum">     474</span>              : #endif</span>
<span id="L475"><span class="lineNum">     475</span>              : </span>
<span id="L476"><span class="lineNum">     476</span>              :   // Extensions: __uninitialized_copy_move, __uninitialized_move_copy,</span>
<span id="L477"><span class="lineNum">     477</span>              :   // __uninitialized_fill_move, __uninitialized_move_fill.</span>
<span id="L478"><span class="lineNum">     478</span>              :   // All of these algorithms take a user-supplied allocator, which is used</span>
<span id="L479"><span class="lineNum">     479</span>              :   // for construction and destruction.</span>
<span id="L480"><span class="lineNum">     480</span>              : </span>
<span id="L481"><span class="lineNum">     481</span>              :   // __uninitialized_copy_move</span>
<span id="L482"><span class="lineNum">     482</span>              :   // Copies [first1, last1) into [result, result + (last1 - first1)), and</span>
<span id="L483"><span class="lineNum">     483</span>              :   //  move [first2, last2) into</span>
<span id="L484"><span class="lineNum">     484</span>              :   //  [result, result + (last1 - first1) + (last2 - first2)).</span>
<span id="L485"><span class="lineNum">     485</span>              :   template&lt;typename _InputIterator1, typename _InputIterator2,</span>
<span id="L486"><span class="lineNum">     486</span>              :            typename _ForwardIterator, typename _Allocator&gt;</span>
<span id="L487"><span class="lineNum">     487</span>              :     inline _ForwardIterator</span>
<span id="L488"><span class="lineNum">     488</span>              :     __uninitialized_copy_move(_InputIterator1 __first1,</span>
<span id="L489"><span class="lineNum">     489</span>              :                               _InputIterator1 __last1,</span>
<span id="L490"><span class="lineNum">     490</span>              :                               _InputIterator2 __first2,</span>
<span id="L491"><span class="lineNum">     491</span>              :                               _InputIterator2 __last2,</span>
<span id="L492"><span class="lineNum">     492</span>              :                               _ForwardIterator __result,</span>
<span id="L493"><span class="lineNum">     493</span>              :                               _Allocator&amp; __alloc)</span>
<span id="L494"><span class="lineNum">     494</span>              :     {</span>
<span id="L495"><span class="lineNum">     495</span>              :       _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,</span>
<span id="L496"><span class="lineNum">     496</span>              :                                                            __result,</span>
<span id="L497"><span class="lineNum">     497</span>              :                                                            __alloc);</span>
<span id="L498"><span class="lineNum">     498</span>              :       __try</span>
<span id="L499"><span class="lineNum">     499</span>              :         {</span>
<span id="L500"><span class="lineNum">     500</span>              :           return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);</span>
<span id="L501"><span class="lineNum">     501</span>              :         }</span>
<span id="L502"><span class="lineNum">     502</span>              :       __catch(...)</span>
<span id="L503"><span class="lineNum">     503</span>              :         {</span>
<span id="L504"><span class="lineNum">     504</span>              :           std::_Destroy(__result, __mid, __alloc);</span>
<span id="L505"><span class="lineNum">     505</span>              :           __throw_exception_again;</span>
<span id="L506"><span class="lineNum">     506</span>              :         }</span>
<span id="L507"><span class="lineNum">     507</span>              :     }</span>
<span id="L508"><span class="lineNum">     508</span>              : </span>
<span id="L509"><span class="lineNum">     509</span>              :   // __uninitialized_move_copy</span>
<span id="L510"><span class="lineNum">     510</span>              :   // Moves [first1, last1) into [result, result + (last1 - first1)), and</span>
<span id="L511"><span class="lineNum">     511</span>              :   //  copies [first2, last2) into</span>
<span id="L512"><span class="lineNum">     512</span>              :   //  [result, result + (last1 - first1) + (last2 - first2)).</span>
<span id="L513"><span class="lineNum">     513</span>              :   template&lt;typename _InputIterator1, typename _InputIterator2,</span>
<span id="L514"><span class="lineNum">     514</span>              :            typename _ForwardIterator, typename _Allocator&gt;</span>
<span id="L515"><span class="lineNum">     515</span>              :     inline _ForwardIterator</span>
<span id="L516"><span class="lineNum">     516</span>              :     __uninitialized_move_copy(_InputIterator1 __first1,</span>
<span id="L517"><span class="lineNum">     517</span>              :                               _InputIterator1 __last1,</span>
<span id="L518"><span class="lineNum">     518</span>              :                               _InputIterator2 __first2,</span>
<span id="L519"><span class="lineNum">     519</span>              :                               _InputIterator2 __last2,</span>
<span id="L520"><span class="lineNum">     520</span>              :                               _ForwardIterator __result,</span>
<span id="L521"><span class="lineNum">     521</span>              :                               _Allocator&amp; __alloc)</span>
<span id="L522"><span class="lineNum">     522</span>              :     {</span>
<span id="L523"><span class="lineNum">     523</span>              :       _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,</span>
<span id="L524"><span class="lineNum">     524</span>              :                                                            __result,</span>
<span id="L525"><span class="lineNum">     525</span>              :                                                            __alloc);</span>
<span id="L526"><span class="lineNum">     526</span>              :       __try</span>
<span id="L527"><span class="lineNum">     527</span>              :         {</span>
<span id="L528"><span class="lineNum">     528</span>              :           return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);</span>
<span id="L529"><span class="lineNum">     529</span>              :         }</span>
<span id="L530"><span class="lineNum">     530</span>              :       __catch(...)</span>
<span id="L531"><span class="lineNum">     531</span>              :         {</span>
<span id="L532"><span class="lineNum">     532</span>              :           std::_Destroy(__result, __mid, __alloc);</span>
<span id="L533"><span class="lineNum">     533</span>              :           __throw_exception_again;</span>
<span id="L534"><span class="lineNum">     534</span>              :         }</span>
<span id="L535"><span class="lineNum">     535</span>              :     }</span>
<span id="L536"><span class="lineNum">     536</span>              : </span>
<span id="L537"><span class="lineNum">     537</span>              :   // __uninitialized_fill_move</span>
<span id="L538"><span class="lineNum">     538</span>              :   // Fills [result, mid) with x, and moves [first, last) into</span>
<span id="L539"><span class="lineNum">     539</span>              :   //  [mid, mid + (last - first)).</span>
<span id="L540"><span class="lineNum">     540</span>              :   template&lt;typename _ForwardIterator, typename _Tp, typename _InputIterator,</span>
<span id="L541"><span class="lineNum">     541</span>              :            typename _Allocator&gt;</span>
<span id="L542"><span class="lineNum">     542</span>              :     inline _ForwardIterator</span>
<span id="L543"><span class="lineNum">     543</span>              :     __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,</span>
<span id="L544"><span class="lineNum">     544</span>              :                               const _Tp&amp; __x, _InputIterator __first,</span>
<span id="L545"><span class="lineNum">     545</span>              :                               _InputIterator __last, _Allocator&amp; __alloc)</span>
<span id="L546"><span class="lineNum">     546</span>              :     {</span>
<span id="L547"><span class="lineNum">     547</span>              :       std::__uninitialized_fill_a(__result, __mid, __x, __alloc);</span>
<span id="L548"><span class="lineNum">     548</span>              :       __try</span>
<span id="L549"><span class="lineNum">     549</span>              :         {</span>
<span id="L550"><span class="lineNum">     550</span>              :           return std::__uninitialized_move_a(__first, __last, __mid, __alloc);</span>
<span id="L551"><span class="lineNum">     551</span>              :         }</span>
<span id="L552"><span class="lineNum">     552</span>              :       __catch(...)</span>
<span id="L553"><span class="lineNum">     553</span>              :         {</span>
<span id="L554"><span class="lineNum">     554</span>              :           std::_Destroy(__result, __mid, __alloc);</span>
<span id="L555"><span class="lineNum">     555</span>              :           __throw_exception_again;</span>
<span id="L556"><span class="lineNum">     556</span>              :         }</span>
<span id="L557"><span class="lineNum">     557</span>              :     }</span>
<span id="L558"><span class="lineNum">     558</span>              : </span>
<span id="L559"><span class="lineNum">     559</span>              :   // __uninitialized_move_fill</span>
<span id="L560"><span class="lineNum">     560</span>              :   // Moves [first1, last1) into [first2, first2 + (last1 - first1)), and</span>
<span id="L561"><span class="lineNum">     561</span>              :   //  fills [first2 + (last1 - first1), last2) with x.</span>
<span id="L562"><span class="lineNum">     562</span>              :   template&lt;typename _InputIterator, typename _ForwardIterator, typename _Tp,</span>
<span id="L563"><span class="lineNum">     563</span>              :            typename _Allocator&gt;</span>
<span id="L564"><span class="lineNum">     564</span>              :     inline void</span>
<span id="L565"><span class="lineNum">     565</span>              :     __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,</span>
<span id="L566"><span class="lineNum">     566</span>              :                               _ForwardIterator __first2,</span>
<span id="L567"><span class="lineNum">     567</span>              :                               _ForwardIterator __last2, const _Tp&amp; __x,</span>
<span id="L568"><span class="lineNum">     568</span>              :                               _Allocator&amp; __alloc)</span>
<span id="L569"><span class="lineNum">     569</span>              :     {</span>
<span id="L570"><span class="lineNum">     570</span>              :       _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,</span>
<span id="L571"><span class="lineNum">     571</span>              :                                                             __first2,</span>
<span id="L572"><span class="lineNum">     572</span>              :                                                             __alloc);</span>
<span id="L573"><span class="lineNum">     573</span>              :       __try</span>
<span id="L574"><span class="lineNum">     574</span>              :         {</span>
<span id="L575"><span class="lineNum">     575</span>              :           std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);</span>
<span id="L576"><span class="lineNum">     576</span>              :         }</span>
<span id="L577"><span class="lineNum">     577</span>              :       __catch(...)</span>
<span id="L578"><span class="lineNum">     578</span>              :         {</span>
<span id="L579"><span class="lineNum">     579</span>              :           std::_Destroy(__first2, __mid2, __alloc);</span>
<span id="L580"><span class="lineNum">     580</span>              :           __throw_exception_again;</span>
<span id="L581"><span class="lineNum">     581</span>              :         }</span>
<span id="L582"><span class="lineNum">     582</span>              :     }</span>
<span id="L583"><span class="lineNum">     583</span>              : </span>
<span id="L584"><span class="lineNum">     584</span>              :   /// @endcond</span>
<span id="L585"><span class="lineNum">     585</span>              : </span>
<span id="L586"><span class="lineNum">     586</span>              : #if __cplusplus &gt;= 201103L</span>
<span id="L587"><span class="lineNum">     587</span>              :   /// @cond undocumented</span>
<span id="L588"><span class="lineNum">     588</span>              : </span>
<span id="L589"><span class="lineNum">     589</span>              :   // Extensions: __uninitialized_default, __uninitialized_default_n,</span>
<span id="L590"><span class="lineNum">     590</span>              :   // __uninitialized_default_a, __uninitialized_default_n_a.</span>
<span id="L591"><span class="lineNum">     591</span>              : </span>
<span id="L592"><span class="lineNum">     592</span>              :   template&lt;bool _TrivialValueType&gt;</span>
<span id="L593"><span class="lineNum">     593</span>              :     struct __uninitialized_default_1</span>
<span id="L594"><span class="lineNum">     594</span>              :     {</span>
<span id="L595"><span class="lineNum">     595</span>              :       template&lt;typename _ForwardIterator&gt;</span>
<span id="L596"><span class="lineNum">     596</span>              :         static void</span>
<span id="L597"><span class="lineNum">     597</span>              :         __uninit_default(_ForwardIterator __first, _ForwardIterator __last)</span>
<span id="L598"><span class="lineNum">     598</span>              :         {</span>
<span id="L599"><span class="lineNum">     599</span>              :           _ForwardIterator __cur = __first;</span>
<span id="L600"><span class="lineNum">     600</span>              :           __try</span>
<span id="L601"><span class="lineNum">     601</span>              :             {</span>
<span id="L602"><span class="lineNum">     602</span>              :               for (; __cur != __last; ++__cur)</span>
<span id="L603"><span class="lineNum">     603</span>              :                 std::_Construct(std::__addressof(*__cur));</span>
<span id="L604"><span class="lineNum">     604</span>              :             }</span>
<span id="L605"><span class="lineNum">     605</span>              :           __catch(...)</span>
<span id="L606"><span class="lineNum">     606</span>              :             {</span>
<span id="L607"><span class="lineNum">     607</span>              :               std::_Destroy(__first, __cur);</span>
<span id="L608"><span class="lineNum">     608</span>              :               __throw_exception_again;</span>
<span id="L609"><span class="lineNum">     609</span>              :             }</span>
<span id="L610"><span class="lineNum">     610</span>              :         }</span>
<span id="L611"><span class="lineNum">     611</span>              :     };</span>
<span id="L612"><span class="lineNum">     612</span>              : </span>
<span id="L613"><span class="lineNum">     613</span>              :   template&lt;&gt;</span>
<span id="L614"><span class="lineNum">     614</span>              :     struct __uninitialized_default_1&lt;true&gt;</span>
<span id="L615"><span class="lineNum">     615</span>              :     {</span>
<span id="L616"><span class="lineNum">     616</span>              :       template&lt;typename _ForwardIterator&gt;</span>
<span id="L617"><span class="lineNum">     617</span>              :         static void</span>
<span id="L618"><span class="lineNum">     618</span>              :         __uninit_default(_ForwardIterator __first, _ForwardIterator __last)</span>
<span id="L619"><span class="lineNum">     619</span>              :         {</span>
<span id="L620"><span class="lineNum">     620</span>              :           if (__first == __last)</span>
<span id="L621"><span class="lineNum">     621</span>              :             return;</span>
<span id="L622"><span class="lineNum">     622</span>              : </span>
<span id="L623"><span class="lineNum">     623</span>              :           typename iterator_traits&lt;_ForwardIterator&gt;::value_type* __val</span>
<span id="L624"><span class="lineNum">     624</span>              :             = std::__addressof(*__first);</span>
<span id="L625"><span class="lineNum">     625</span>              :           std::_Construct(__val);</span>
<span id="L626"><span class="lineNum">     626</span>              :           if (++__first != __last)</span>
<span id="L627"><span class="lineNum">     627</span>              :             std::fill(__first, __last, *__val);</span>
<span id="L628"><span class="lineNum">     628</span>              :         }</span>
<span id="L629"><span class="lineNum">     629</span>              :     };</span>
<span id="L630"><span class="lineNum">     630</span>              : </span>
<span id="L631"><span class="lineNum">     631</span>              :   template&lt;bool _TrivialValueType&gt;</span>
<span id="L632"><span class="lineNum">     632</span>              :     struct __uninitialized_default_n_1</span>
<span id="L633"><span class="lineNum">     633</span>              :     {</span>
<span id="L634"><span class="lineNum">     634</span>              :       template&lt;typename _ForwardIterator, typename _Size&gt;</span>
<span id="L635"><span class="lineNum">     635</span>              :         _GLIBCXX20_CONSTEXPR</span>
<span id="L636"><span class="lineNum">     636</span>              :         static _ForwardIterator</span>
<span id="L637"><span class="lineNum">     637</span>              :         __uninit_default_n(_ForwardIterator __first, _Size __n)</span>
<span id="L638"><span class="lineNum">     638</span>              :         {</span>
<span id="L639"><span class="lineNum">     639</span>              :           _ForwardIterator __cur = __first;</span>
<span id="L640"><span class="lineNum">     640</span>              :           __try</span>
<span id="L641"><span class="lineNum">     641</span>              :             {</span>
<span id="L642"><span class="lineNum">     642</span>              :               for (; __n &gt; 0; --__n, (void) ++__cur)</span>
<span id="L643"><span class="lineNum">     643</span>              :                 std::_Construct(std::__addressof(*__cur));</span>
<span id="L644"><span class="lineNum">     644</span>              :               return __cur;</span>
<span id="L645"><span class="lineNum">     645</span>              :             }</span>
<span id="L646"><span class="lineNum">     646</span>              :           __catch(...)</span>
<span id="L647"><span class="lineNum">     647</span>              :             {</span>
<span id="L648"><span class="lineNum">     648</span>              :               std::_Destroy(__first, __cur);</span>
<span id="L649"><span class="lineNum">     649</span>              :               __throw_exception_again;</span>
<span id="L650"><span class="lineNum">     650</span>              :             }</span>
<span id="L651"><span class="lineNum">     651</span>              :         }</span>
<span id="L652"><span class="lineNum">     652</span>              :     };</span>
<span id="L653"><span class="lineNum">     653</span>              : </span>
<span id="L654"><span class="lineNum">     654</span>              :   template&lt;&gt;</span>
<span id="L655"><span class="lineNum">     655</span>              :     struct __uninitialized_default_n_1&lt;true&gt;</span>
<span id="L656"><span class="lineNum">     656</span>              :     {</span>
<span id="L657"><span class="lineNum">     657</span>              :       template&lt;typename _ForwardIterator, typename _Size&gt;</span>
<span id="L658"><span class="lineNum">     658</span>              :         _GLIBCXX20_CONSTEXPR</span>
<span id="L659"><span class="lineNum">     659</span>              :         static _ForwardIterator</span>
<span id="L660"><span class="lineNum">     660</span>              :         __uninit_default_n(_ForwardIterator __first, _Size __n)</span>
<span id="L661"><span class="lineNum">     661</span>              :         {</span>
<span id="L662"><span class="lineNum">     662</span>              :           if (__n &gt; 0)</span>
<span id="L663"><span class="lineNum">     663</span>              :             {</span>
<span id="L664"><span class="lineNum">     664</span>              :               typename iterator_traits&lt;_ForwardIterator&gt;::value_type* __val</span>
<span id="L665"><span class="lineNum">     665</span>              :                 = std::__addressof(*__first);</span>
<span id="L666"><span class="lineNum">     666</span>              :               std::_Construct(__val);</span>
<span id="L667"><span class="lineNum">     667</span>              :               ++__first;</span>
<span id="L668"><span class="lineNum">     668</span>              :               __first = std::fill_n(__first, __n - 1, *__val);</span>
<span id="L669"><span class="lineNum">     669</span>              :             }</span>
<span id="L670"><span class="lineNum">     670</span>              :           return __first;</span>
<span id="L671"><span class="lineNum">     671</span>              :         }</span>
<span id="L672"><span class="lineNum">     672</span>              :     };</span>
<span id="L673"><span class="lineNum">     673</span>              : </span>
<span id="L674"><span class="lineNum">     674</span>              :   // __uninitialized_default</span>
<span id="L675"><span class="lineNum">     675</span>              :   // Fills [first, last) with value-initialized value_types.</span>
<span id="L676"><span class="lineNum">     676</span>              :   template&lt;typename _ForwardIterator&gt;</span>
<span id="L677"><span class="lineNum">     677</span>              :     inline void</span>
<span id="L678"><span class="lineNum">     678</span>              :     __uninitialized_default(_ForwardIterator __first,</span>
<span id="L679"><span class="lineNum">     679</span>              :                             _ForwardIterator __last)</span>
<span id="L680"><span class="lineNum">     680</span>              :     {</span>
<span id="L681"><span class="lineNum">     681</span>              :       typedef typename iterator_traits&lt;_ForwardIterator&gt;::value_type</span>
<span id="L682"><span class="lineNum">     682</span>              :         _ValueType;</span>
<span id="L683"><span class="lineNum">     683</span>              :       // trivial types can have deleted assignment</span>
<span id="L684"><span class="lineNum">     684</span>              :       const bool __assignable = is_copy_assignable&lt;_ValueType&gt;::value;</span>
<span id="L685"><span class="lineNum">     685</span>              : </span>
<span id="L686"><span class="lineNum">     686</span>              :       std::__uninitialized_default_1&lt;__is_trivial(_ValueType)</span>
<span id="L687"><span class="lineNum">     687</span>              :                                      &amp;&amp; __assignable&gt;::</span>
<span id="L688"><span class="lineNum">     688</span>              :         __uninit_default(__first, __last);</span>
<span id="L689"><span class="lineNum">     689</span>              :     }</span>
<span id="L690"><span class="lineNum">     690</span>              : </span>
<span id="L691"><span class="lineNum">     691</span>              :   // __uninitialized_default_n</span>
<span id="L692"><span class="lineNum">     692</span>              :   // Fills [first, first + n) with value-initialized value_types.</span>
<span id="L693"><span class="lineNum">     693</span>              :   template&lt;typename _ForwardIterator, typename _Size&gt;</span>
<span id="L694"><span class="lineNum">     694</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L695"><span class="lineNum">     695</span>              :     inline _ForwardIterator</span>
<span id="L696"><span class="lineNum">     696</span>              :     __uninitialized_default_n(_ForwardIterator __first, _Size __n)</span>
<span id="L697"><span class="lineNum">     697</span>              :     {</span>
<span id="L698"><span class="lineNum">     698</span>              : #ifdef __cpp_lib_is_constant_evaluated</span>
<span id="L699"><span class="lineNum">     699</span>              :       if (std::is_constant_evaluated())</span>
<span id="L700"><span class="lineNum">     700</span>              :         return __uninitialized_default_n_1&lt;false&gt;::</span>
<span id="L701"><span class="lineNum">     701</span>              :                  __uninit_default_n(__first, __n);</span>
<span id="L702"><span class="lineNum">     702</span>              : #endif</span>
<span id="L703"><span class="lineNum">     703</span>              : </span>
<span id="L704"><span class="lineNum">     704</span>              :       typedef typename iterator_traits&lt;_ForwardIterator&gt;::value_type</span>
<span id="L705"><span class="lineNum">     705</span>              :         _ValueType;</span>
<span id="L706"><span class="lineNum">     706</span>              :       // See uninitialized_fill_n for the conditions for using std::fill_n.</span>
<span id="L707"><span class="lineNum">     707</span>              :       constexpr bool __can_fill</span>
<span id="L708"><span class="lineNum">     708</span>              :         = __and_&lt;is_integral&lt;_Size&gt;, is_copy_assignable&lt;_ValueType&gt;&gt;::value;</span>
<span id="L709"><span class="lineNum">     709</span>              : </span>
<span id="L710"><span class="lineNum">     710</span>              :       return __uninitialized_default_n_1&lt;__is_trivial(_ValueType)</span>
<span id="L711"><span class="lineNum">     711</span>              :                                          &amp;&amp; __can_fill&gt;::</span>
<span id="L712"><span class="lineNum">     712</span>              :         __uninit_default_n(__first, __n);</span>
<span id="L713"><span class="lineNum">     713</span>              :     }</span>
<span id="L714"><span class="lineNum">     714</span>              : </span>
<span id="L715"><span class="lineNum">     715</span>              : </span>
<span id="L716"><span class="lineNum">     716</span>              :   // __uninitialized_default_a</span>
<span id="L717"><span class="lineNum">     717</span>              :   // Fills [first, last) with value_types constructed by the allocator</span>
<span id="L718"><span class="lineNum">     718</span>              :   // alloc, with no arguments passed to the construct call.</span>
<span id="L719"><span class="lineNum">     719</span>              :   template&lt;typename _ForwardIterator, typename _Allocator&gt;</span>
<span id="L720"><span class="lineNum">     720</span>              :     void</span>
<span id="L721"><span class="lineNum">     721</span>              :     __uninitialized_default_a(_ForwardIterator __first,</span>
<span id="L722"><span class="lineNum">     722</span>              :                               _ForwardIterator __last,</span>
<span id="L723"><span class="lineNum">     723</span>              :                               _Allocator&amp; __alloc)</span>
<span id="L724"><span class="lineNum">     724</span>              :     {</span>
<span id="L725"><span class="lineNum">     725</span>              :       _ForwardIterator __cur = __first;</span>
<span id="L726"><span class="lineNum">     726</span>              :       __try</span>
<span id="L727"><span class="lineNum">     727</span>              :         {</span>
<span id="L728"><span class="lineNum">     728</span>              :           typedef __gnu_cxx::__alloc_traits&lt;_Allocator&gt; __traits;</span>
<span id="L729"><span class="lineNum">     729</span>              :           for (; __cur != __last; ++__cur)</span>
<span id="L730"><span class="lineNum">     730</span>              :             __traits::construct(__alloc, std::__addressof(*__cur));</span>
<span id="L731"><span class="lineNum">     731</span>              :         }</span>
<span id="L732"><span class="lineNum">     732</span>              :       __catch(...)</span>
<span id="L733"><span class="lineNum">     733</span>              :         {</span>
<span id="L734"><span class="lineNum">     734</span>              :           std::_Destroy(__first, __cur, __alloc);</span>
<span id="L735"><span class="lineNum">     735</span>              :           __throw_exception_again;</span>
<span id="L736"><span class="lineNum">     736</span>              :         }</span>
<span id="L737"><span class="lineNum">     737</span>              :     }</span>
<span id="L738"><span class="lineNum">     738</span>              : </span>
<span id="L739"><span class="lineNum">     739</span>              : #if _GLIBCXX_HOSTED</span>
<span id="L740"><span class="lineNum">     740</span>              :   template&lt;typename _ForwardIterator, typename _Tp&gt;</span>
<span id="L741"><span class="lineNum">     741</span>              :     inline void</span>
<span id="L742"><span class="lineNum">     742</span>              :     __uninitialized_default_a(_ForwardIterator __first,</span>
<span id="L743"><span class="lineNum">     743</span>              :                               _ForwardIterator __last,</span>
<span id="L744"><span class="lineNum">     744</span>              :                               allocator&lt;_Tp&gt;&amp;)</span>
<span id="L745"><span class="lineNum">     745</span>              :     { std::__uninitialized_default(__first, __last); }</span>
<span id="L746"><span class="lineNum">     746</span>              : #endif</span>
<span id="L747"><span class="lineNum">     747</span>              : </span>
<span id="L748"><span class="lineNum">     748</span>              :   // __uninitialized_default_n_a</span>
<span id="L749"><span class="lineNum">     749</span>              :   // Fills [first, first + n) with value_types constructed by the allocator</span>
<span id="L750"><span class="lineNum">     750</span>              :   // alloc, with no arguments passed to the construct call.</span>
<span id="L751"><span class="lineNum">     751</span>              :   template&lt;typename _ForwardIterator, typename _Size, typename _Allocator&gt;</span>
<span id="L752"><span class="lineNum">     752</span>              :     _GLIBCXX20_CONSTEXPR _ForwardIterator</span>
<span id="L753"><span class="lineNum">     753</span>              :     __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,</span>
<span id="L754"><span class="lineNum">     754</span>              :                                 _Allocator&amp; __alloc)</span>
<span id="L755"><span class="lineNum">     755</span>              :     {</span>
<span id="L756"><span class="lineNum">     756</span>              :       _ForwardIterator __cur = __first;</span>
<span id="L757"><span class="lineNum">     757</span>              :       __try</span>
<span id="L758"><span class="lineNum">     758</span>              :         {</span>
<span id="L759"><span class="lineNum">     759</span>              :           typedef __gnu_cxx::__alloc_traits&lt;_Allocator&gt; __traits;</span>
<span id="L760"><span class="lineNum">     760</span>              :           for (; __n &gt; 0; --__n, (void) ++__cur)</span>
<span id="L761"><span class="lineNum">     761</span>              :             __traits::construct(__alloc, std::__addressof(*__cur));</span>
<span id="L762"><span class="lineNum">     762</span>              :           return __cur;</span>
<span id="L763"><span class="lineNum">     763</span>              :         }</span>
<span id="L764"><span class="lineNum">     764</span>              :       __catch(...)</span>
<span id="L765"><span class="lineNum">     765</span>              :         {</span>
<span id="L766"><span class="lineNum">     766</span>              :           std::_Destroy(__first, __cur, __alloc);</span>
<span id="L767"><span class="lineNum">     767</span>              :           __throw_exception_again;</span>
<span id="L768"><span class="lineNum">     768</span>              :         }</span>
<span id="L769"><span class="lineNum">     769</span>              :     }</span>
<span id="L770"><span class="lineNum">     770</span>              : </span>
<span id="L771"><span class="lineNum">     771</span>              : #if _GLIBCXX_HOSTED</span>
<span id="L772"><span class="lineNum">     772</span>              :   // __uninitialized_default_n_a specialization for std::allocator,</span>
<span id="L773"><span class="lineNum">     773</span>              :   // which ignores the allocator and value-initializes the elements.</span>
<span id="L774"><span class="lineNum">     774</span>              :   template&lt;typename _ForwardIterator, typename _Size, typename _Tp&gt;</span>
<span id="L775"><span class="lineNum">     775</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L776"><span class="lineNum">     776</span>              :     inline _ForwardIterator</span>
<span id="L777"><span class="lineNum">     777</span>              :     __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,</span>
<span id="L778"><span class="lineNum">     778</span>              :                                 allocator&lt;_Tp&gt;&amp;)</span>
<span id="L779"><span class="lineNum">     779</span>              :     { return std::__uninitialized_default_n(__first, __n); }</span>
<span id="L780"><span class="lineNum">     780</span>              : #endif</span>
<span id="L781"><span class="lineNum">     781</span>              : </span>
<span id="L782"><span class="lineNum">     782</span>              :   template&lt;bool _TrivialValueType&gt;</span>
<span id="L783"><span class="lineNum">     783</span>              :     struct __uninitialized_default_novalue_1</span>
<span id="L784"><span class="lineNum">     784</span>              :     {</span>
<span id="L785"><span class="lineNum">     785</span>              :       template&lt;typename _ForwardIterator&gt;</span>
<span id="L786"><span class="lineNum">     786</span>              :         static void</span>
<span id="L787"><span class="lineNum">     787</span>              :         __uninit_default_novalue(_ForwardIterator __first,</span>
<span id="L788"><span class="lineNum">     788</span>              :                                  _ForwardIterator __last)</span>
<span id="L789"><span class="lineNum">     789</span>              :         {</span>
<span id="L790"><span class="lineNum">     790</span>              :           _ForwardIterator __cur = __first;</span>
<span id="L791"><span class="lineNum">     791</span>              :           __try</span>
<span id="L792"><span class="lineNum">     792</span>              :             {</span>
<span id="L793"><span class="lineNum">     793</span>              :               for (; __cur != __last; ++__cur)</span>
<span id="L794"><span class="lineNum">     794</span>              :                 std::_Construct_novalue(std::__addressof(*__cur));</span>
<span id="L795"><span class="lineNum">     795</span>              :             }</span>
<span id="L796"><span class="lineNum">     796</span>              :           __catch(...)</span>
<span id="L797"><span class="lineNum">     797</span>              :             {</span>
<span id="L798"><span class="lineNum">     798</span>              :               std::_Destroy(__first, __cur);</span>
<span id="L799"><span class="lineNum">     799</span>              :               __throw_exception_again;</span>
<span id="L800"><span class="lineNum">     800</span>              :             }</span>
<span id="L801"><span class="lineNum">     801</span>              :         }</span>
<span id="L802"><span class="lineNum">     802</span>              :     };</span>
<span id="L803"><span class="lineNum">     803</span>              : </span>
<span id="L804"><span class="lineNum">     804</span>              :   template&lt;&gt;</span>
<span id="L805"><span class="lineNum">     805</span>              :     struct __uninitialized_default_novalue_1&lt;true&gt;</span>
<span id="L806"><span class="lineNum">     806</span>              :     {</span>
<span id="L807"><span class="lineNum">     807</span>              :       template&lt;typename _ForwardIterator&gt;</span>
<span id="L808"><span class="lineNum">     808</span>              :         static void</span>
<span id="L809"><span class="lineNum">     809</span>              :         __uninit_default_novalue(_ForwardIterator, _ForwardIterator)</span>
<span id="L810"><span class="lineNum">     810</span>              :         {</span>
<span id="L811"><span class="lineNum">     811</span>              :         }</span>
<span id="L812"><span class="lineNum">     812</span>              :     };</span>
<span id="L813"><span class="lineNum">     813</span>              : </span>
<span id="L814"><span class="lineNum">     814</span>              :   template&lt;bool _TrivialValueType&gt;</span>
<span id="L815"><span class="lineNum">     815</span>              :     struct __uninitialized_default_novalue_n_1</span>
<span id="L816"><span class="lineNum">     816</span>              :     {</span>
<span id="L817"><span class="lineNum">     817</span>              :       template&lt;typename _ForwardIterator, typename _Size&gt;</span>
<span id="L818"><span class="lineNum">     818</span>              :         static _ForwardIterator</span>
<span id="L819"><span class="lineNum">     819</span>              :         __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)</span>
<span id="L820"><span class="lineNum">     820</span>              :         {</span>
<span id="L821"><span class="lineNum">     821</span>              :           _ForwardIterator __cur = __first;</span>
<span id="L822"><span class="lineNum">     822</span>              :           __try</span>
<span id="L823"><span class="lineNum">     823</span>              :             {</span>
<span id="L824"><span class="lineNum">     824</span>              :               for (; __n &gt; 0; --__n, (void) ++__cur)</span>
<span id="L825"><span class="lineNum">     825</span>              :                 std::_Construct_novalue(std::__addressof(*__cur));</span>
<span id="L826"><span class="lineNum">     826</span>              :               return __cur;</span>
<span id="L827"><span class="lineNum">     827</span>              :             }</span>
<span id="L828"><span class="lineNum">     828</span>              :           __catch(...)</span>
<span id="L829"><span class="lineNum">     829</span>              :             {</span>
<span id="L830"><span class="lineNum">     830</span>              :               std::_Destroy(__first, __cur);</span>
<span id="L831"><span class="lineNum">     831</span>              :               __throw_exception_again;</span>
<span id="L832"><span class="lineNum">     832</span>              :             }</span>
<span id="L833"><span class="lineNum">     833</span>              :         }</span>
<span id="L834"><span class="lineNum">     834</span>              :     };</span>
<span id="L835"><span class="lineNum">     835</span>              : </span>
<span id="L836"><span class="lineNum">     836</span>              :   template&lt;&gt;</span>
<span id="L837"><span class="lineNum">     837</span>              :     struct __uninitialized_default_novalue_n_1&lt;true&gt;</span>
<span id="L838"><span class="lineNum">     838</span>              :     {</span>
<span id="L839"><span class="lineNum">     839</span>              :       template&lt;typename _ForwardIterator, typename _Size&gt;</span>
<span id="L840"><span class="lineNum">     840</span>              :         static _ForwardIterator</span>
<span id="L841"><span class="lineNum">     841</span>              :         __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)</span>
<span id="L842"><span class="lineNum">     842</span>              :         { return std::next(__first, __n); }</span>
<span id="L843"><span class="lineNum">     843</span>              :     };</span>
<span id="L844"><span class="lineNum">     844</span>              : </span>
<span id="L845"><span class="lineNum">     845</span>              :   // __uninitialized_default_novalue</span>
<span id="L846"><span class="lineNum">     846</span>              :   // Fills [first, last) with default-initialized value_types.</span>
<span id="L847"><span class="lineNum">     847</span>              :   template&lt;typename _ForwardIterator&gt;</span>
<span id="L848"><span class="lineNum">     848</span>              :     inline void</span>
<span id="L849"><span class="lineNum">     849</span>              :     __uninitialized_default_novalue(_ForwardIterator __first,</span>
<span id="L850"><span class="lineNum">     850</span>              :                                     _ForwardIterator __last)</span>
<span id="L851"><span class="lineNum">     851</span>              :     {</span>
<span id="L852"><span class="lineNum">     852</span>              :       typedef typename iterator_traits&lt;_ForwardIterator&gt;::value_type</span>
<span id="L853"><span class="lineNum">     853</span>              :         _ValueType;</span>
<span id="L854"><span class="lineNum">     854</span>              : </span>
<span id="L855"><span class="lineNum">     855</span>              :       std::__uninitialized_default_novalue_1&lt;</span>
<span id="L856"><span class="lineNum">     856</span>              :         is_trivially_default_constructible&lt;_ValueType&gt;::value&gt;::</span>
<span id="L857"><span class="lineNum">     857</span>              :         __uninit_default_novalue(__first, __last);</span>
<span id="L858"><span class="lineNum">     858</span>              :     }</span>
<span id="L859"><span class="lineNum">     859</span>              : </span>
<span id="L860"><span class="lineNum">     860</span>              :   // __uninitialized_default_novalue_n</span>
<span id="L861"><span class="lineNum">     861</span>              :   // Fills [first, first + n) with default-initialized value_types.</span>
<span id="L862"><span class="lineNum">     862</span>              :   template&lt;typename _ForwardIterator, typename _Size&gt;</span>
<span id="L863"><span class="lineNum">     863</span>              :     inline _ForwardIterator</span>
<span id="L864"><span class="lineNum">     864</span>              :     __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n)</span>
<span id="L865"><span class="lineNum">     865</span>              :     {</span>
<span id="L866"><span class="lineNum">     866</span>              :       typedef typename iterator_traits&lt;_ForwardIterator&gt;::value_type</span>
<span id="L867"><span class="lineNum">     867</span>              :         _ValueType;</span>
<span id="L868"><span class="lineNum">     868</span>              : </span>
<span id="L869"><span class="lineNum">     869</span>              :       return __uninitialized_default_novalue_n_1&lt;</span>
<span id="L870"><span class="lineNum">     870</span>              :         is_trivially_default_constructible&lt;_ValueType&gt;::value&gt;::</span>
<span id="L871"><span class="lineNum">     871</span>              :         __uninit_default_novalue_n(__first, __n);</span>
<span id="L872"><span class="lineNum">     872</span>              :     }</span>
<span id="L873"><span class="lineNum">     873</span>              : </span>
<span id="L874"><span class="lineNum">     874</span>              :   template&lt;typename _InputIterator, typename _Size,</span>
<span id="L875"><span class="lineNum">     875</span>              :            typename _ForwardIterator&gt;</span>
<span id="L876"><span class="lineNum">     876</span>              :     _ForwardIterator</span>
<span id="L877"><span class="lineNum">     877</span>              :     __uninitialized_copy_n(_InputIterator __first, _Size __n,</span>
<span id="L878"><span class="lineNum">     878</span>              :                            _ForwardIterator __result, input_iterator_tag)</span>
<span id="L879"><span class="lineNum">     879</span>              :     {</span>
<span id="L880"><span class="lineNum">     880</span>              :       _ForwardIterator __cur = __result;</span>
<span id="L881"><span class="lineNum">     881</span>              :       __try</span>
<span id="L882"><span class="lineNum">     882</span>              :         {</span>
<span id="L883"><span class="lineNum">     883</span>              :           for (; __n &gt; 0; --__n, (void) ++__first, ++__cur)</span>
<span id="L884"><span class="lineNum">     884</span>              :             std::_Construct(std::__addressof(*__cur), *__first);</span>
<span id="L885"><span class="lineNum">     885</span>              :           return __cur;</span>
<span id="L886"><span class="lineNum">     886</span>              :         }</span>
<span id="L887"><span class="lineNum">     887</span>              :       __catch(...)</span>
<span id="L888"><span class="lineNum">     888</span>              :         {</span>
<span id="L889"><span class="lineNum">     889</span>              :           std::_Destroy(__result, __cur);</span>
<span id="L890"><span class="lineNum">     890</span>              :           __throw_exception_again;</span>
<span id="L891"><span class="lineNum">     891</span>              :         }</span>
<span id="L892"><span class="lineNum">     892</span>              :     }</span>
<span id="L893"><span class="lineNum">     893</span>              : </span>
<span id="L894"><span class="lineNum">     894</span>              :   template&lt;typename _RandomAccessIterator, typename _Size,</span>
<span id="L895"><span class="lineNum">     895</span>              :            typename _ForwardIterator&gt;</span>
<span id="L896"><span class="lineNum">     896</span>              :     inline _ForwardIterator</span>
<span id="L897"><span class="lineNum">     897</span>              :     __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,</span>
<span id="L898"><span class="lineNum">     898</span>              :                            _ForwardIterator __result,</span>
<span id="L899"><span class="lineNum">     899</span>              :                            random_access_iterator_tag)</span>
<span id="L900"><span class="lineNum">     900</span>              :     { return std::uninitialized_copy(__first, __first + __n, __result); }</span>
<span id="L901"><span class="lineNum">     901</span>              : </span>
<span id="L902"><span class="lineNum">     902</span>              :   template&lt;typename _InputIterator, typename _Size,</span>
<span id="L903"><span class="lineNum">     903</span>              :            typename _ForwardIterator&gt;</span>
<span id="L904"><span class="lineNum">     904</span>              :     pair&lt;_InputIterator, _ForwardIterator&gt;</span>
<span id="L905"><span class="lineNum">     905</span>              :     __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,</span>
<span id="L906"><span class="lineNum">     906</span>              :                            _ForwardIterator __result, input_iterator_tag)</span>
<span id="L907"><span class="lineNum">     907</span>              :     {</span>
<span id="L908"><span class="lineNum">     908</span>              :       _ForwardIterator __cur = __result;</span>
<span id="L909"><span class="lineNum">     909</span>              :       __try</span>
<span id="L910"><span class="lineNum">     910</span>              :         {</span>
<span id="L911"><span class="lineNum">     911</span>              :           for (; __n &gt; 0; --__n, (void) ++__first, ++__cur)</span>
<span id="L912"><span class="lineNum">     912</span>              :             std::_Construct(std::__addressof(*__cur), *__first);</span>
<span id="L913"><span class="lineNum">     913</span>              :           return {__first, __cur};</span>
<span id="L914"><span class="lineNum">     914</span>              :         }</span>
<span id="L915"><span class="lineNum">     915</span>              :       __catch(...)</span>
<span id="L916"><span class="lineNum">     916</span>              :         {</span>
<span id="L917"><span class="lineNum">     917</span>              :           std::_Destroy(__result, __cur);</span>
<span id="L918"><span class="lineNum">     918</span>              :           __throw_exception_again;</span>
<span id="L919"><span class="lineNum">     919</span>              :         }</span>
<span id="L920"><span class="lineNum">     920</span>              :     }</span>
<span id="L921"><span class="lineNum">     921</span>              : </span>
<span id="L922"><span class="lineNum">     922</span>              :   template&lt;typename _RandomAccessIterator, typename _Size,</span>
<span id="L923"><span class="lineNum">     923</span>              :            typename _ForwardIterator&gt;</span>
<span id="L924"><span class="lineNum">     924</span>              :     inline pair&lt;_RandomAccessIterator, _ForwardIterator&gt;</span>
<span id="L925"><span class="lineNum">     925</span>              :     __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n,</span>
<span id="L926"><span class="lineNum">     926</span>              :                            _ForwardIterator __result,</span>
<span id="L927"><span class="lineNum">     927</span>              :                            random_access_iterator_tag)</span>
<span id="L928"><span class="lineNum">     928</span>              :     {</span>
<span id="L929"><span class="lineNum">     929</span>              :       auto __second_res = uninitialized_copy(__first, __first + __n, __result);</span>
<span id="L930"><span class="lineNum">     930</span>              :       auto __first_res = std::next(__first, __n);</span>
<span id="L931"><span class="lineNum">     931</span>              :       return {__first_res, __second_res};</span>
<span id="L932"><span class="lineNum">     932</span>              :     }</span>
<span id="L933"><span class="lineNum">     933</span>              : </span>
<span id="L934"><span class="lineNum">     934</span>              :   /// @endcond</span>
<span id="L935"><span class="lineNum">     935</span>              : </span>
<span id="L936"><span class="lineNum">     936</span>              :   /**</span>
<span id="L937"><span class="lineNum">     937</span>              :    *  @brief Copies the range [first,first+n) into result.</span>
<span id="L938"><span class="lineNum">     938</span>              :    *  @param  __first  An input iterator.</span>
<span id="L939"><span class="lineNum">     939</span>              :    *  @param  __n      The number of elements to copy.</span>
<span id="L940"><span class="lineNum">     940</span>              :    *  @param  __result An output iterator.</span>
<span id="L941"><span class="lineNum">     941</span>              :    *  @return  __result + __n</span>
<span id="L942"><span class="lineNum">     942</span>              :    *  @since C++11</span>
<span id="L943"><span class="lineNum">     943</span>              :    *</span>
<span id="L944"><span class="lineNum">     944</span>              :    *  Like copy_n(), but does not require an initialized output range.</span>
<span id="L945"><span class="lineNum">     945</span>              :   */</span>
<span id="L946"><span class="lineNum">     946</span>              :   template&lt;typename _InputIterator, typename _Size, typename _ForwardIterator&gt;</span>
<span id="L947"><span class="lineNum">     947</span>              :     inline _ForwardIterator</span>
<span id="L948"><span class="lineNum">     948</span>              :     uninitialized_copy_n(_InputIterator __first, _Size __n,</span>
<span id="L949"><span class="lineNum">     949</span>              :                          _ForwardIterator __result)</span>
<span id="L950"><span class="lineNum">     950</span>              :     { return std::__uninitialized_copy_n(__first, __n, __result,</span>
<span id="L951"><span class="lineNum">     951</span>              :                                          std::__iterator_category(__first)); }</span>
<span id="L952"><span class="lineNum">     952</span>              : </span>
<span id="L953"><span class="lineNum">     953</span>              :   /// @cond undocumented</span>
<span id="L954"><span class="lineNum">     954</span>              :   template&lt;typename _InputIterator, typename _Size, typename _ForwardIterator&gt;</span>
<span id="L955"><span class="lineNum">     955</span>              :     inline pair&lt;_InputIterator, _ForwardIterator&gt;</span>
<span id="L956"><span class="lineNum">     956</span>              :     __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,</span>
<span id="L957"><span class="lineNum">     957</span>              :                               _ForwardIterator __result)</span>
<span id="L958"><span class="lineNum">     958</span>              :     {</span>
<span id="L959"><span class="lineNum">     959</span>              :       return</span>
<span id="L960"><span class="lineNum">     960</span>              :         std::__uninitialized_copy_n_pair(__first, __n, __result,</span>
<span id="L961"><span class="lineNum">     961</span>              :                                          std::__iterator_category(__first));</span>
<span id="L962"><span class="lineNum">     962</span>              :     }</span>
<span id="L963"><span class="lineNum">     963</span>              :   /// @endcond</span>
<span id="L964"><span class="lineNum">     964</span>              : #endif</span>
<span id="L965"><span class="lineNum">     965</span>              : </span>
<span id="L966"><span class="lineNum">     966</span>              : #if __cplusplus &gt;= 201703L</span>
<span id="L967"><span class="lineNum">     967</span>              : # define __cpp_lib_raw_memory_algorithms 201606L</span>
<span id="L968"><span class="lineNum">     968</span>              : </span>
<span id="L969"><span class="lineNum">     969</span>              :   /**</span>
<span id="L970"><span class="lineNum">     970</span>              :    *  @brief Default-initializes objects in the range [first,last).</span>
<span id="L971"><span class="lineNum">     971</span>              :    *  @param  __first  A forward iterator.</span>
<span id="L972"><span class="lineNum">     972</span>              :    *  @param  __last   A forward iterator.</span>
<span id="L973"><span class="lineNum">     973</span>              :    *  @since C++17</span>
<span id="L974"><span class="lineNum">     974</span>              :   */</span>
<span id="L975"><span class="lineNum">     975</span>              :   template &lt;typename _ForwardIterator&gt;</span>
<span id="L976"><span class="lineNum">     976</span>              :     inline void</span>
<span id="L977"><span class="lineNum">     977</span>              :     uninitialized_default_construct(_ForwardIterator __first,</span>
<span id="L978"><span class="lineNum">     978</span>              :                                     _ForwardIterator __last)</span>
<span id="L979"><span class="lineNum">     979</span>              :     {</span>
<span id="L980"><span class="lineNum">     980</span>              :       __uninitialized_default_novalue(__first, __last);</span>
<span id="L981"><span class="lineNum">     981</span>              :     }</span>
<span id="L982"><span class="lineNum">     982</span>              : </span>
<span id="L983"><span class="lineNum">     983</span>              :   /**</span>
<span id="L984"><span class="lineNum">     984</span>              :    *  @brief Default-initializes objects in the range [first,first+count).</span>
<span id="L985"><span class="lineNum">     985</span>              :    *  @param  __first  A forward iterator.</span>
<span id="L986"><span class="lineNum">     986</span>              :    *  @param  __count  The number of objects to construct.</span>
<span id="L987"><span class="lineNum">     987</span>              :    *  @return   __first + __count</span>
<span id="L988"><span class="lineNum">     988</span>              :    *  @since C++17</span>
<span id="L989"><span class="lineNum">     989</span>              :   */</span>
<span id="L990"><span class="lineNum">     990</span>              :   template &lt;typename _ForwardIterator, typename _Size&gt;</span>
<span id="L991"><span class="lineNum">     991</span>              :     inline _ForwardIterator</span>
<span id="L992"><span class="lineNum">     992</span>              :     uninitialized_default_construct_n(_ForwardIterator __first, _Size __count)</span>
<span id="L993"><span class="lineNum">     993</span>              :     {</span>
<span id="L994"><span class="lineNum">     994</span>              :       return __uninitialized_default_novalue_n(__first, __count);</span>
<span id="L995"><span class="lineNum">     995</span>              :     }</span>
<span id="L996"><span class="lineNum">     996</span>              : </span>
<span id="L997"><span class="lineNum">     997</span>              :   /**</span>
<span id="L998"><span class="lineNum">     998</span>              :    *  @brief Value-initializes objects in the range [first,last).</span>
<span id="L999"><span class="lineNum">     999</span>              :    *  @param  __first  A forward iterator.</span>
<span id="L1000"><span class="lineNum">    1000</span>              :    *  @param  __last   A forward iterator.</span>
<span id="L1001"><span class="lineNum">    1001</span>              :    *  @since C++17</span>
<span id="L1002"><span class="lineNum">    1002</span>              :   */</span>
<span id="L1003"><span class="lineNum">    1003</span>              :   template &lt;typename _ForwardIterator&gt;</span>
<span id="L1004"><span class="lineNum">    1004</span>              :     inline void</span>
<span id="L1005"><span class="lineNum">    1005</span>              :     uninitialized_value_construct(_ForwardIterator __first,</span>
<span id="L1006"><span class="lineNum">    1006</span>              :                                   _ForwardIterator __last)</span>
<span id="L1007"><span class="lineNum">    1007</span>              :     {</span>
<span id="L1008"><span class="lineNum">    1008</span>              :       return __uninitialized_default(__first, __last);</span>
<span id="L1009"><span class="lineNum">    1009</span>              :     }</span>
<span id="L1010"><span class="lineNum">    1010</span>              : </span>
<span id="L1011"><span class="lineNum">    1011</span>              :   /**</span>
<span id="L1012"><span class="lineNum">    1012</span>              :    *  @brief Value-initializes objects in the range [first,first+count).</span>
<span id="L1013"><span class="lineNum">    1013</span>              :    *  @param  __first  A forward iterator.</span>
<span id="L1014"><span class="lineNum">    1014</span>              :    *  @param  __count  The number of objects to construct.</span>
<span id="L1015"><span class="lineNum">    1015</span>              :    *  @return   __result + __count</span>
<span id="L1016"><span class="lineNum">    1016</span>              :    *  @since C++17</span>
<span id="L1017"><span class="lineNum">    1017</span>              :   */</span>
<span id="L1018"><span class="lineNum">    1018</span>              :   template &lt;typename _ForwardIterator, typename _Size&gt;</span>
<span id="L1019"><span class="lineNum">    1019</span>              :     inline _ForwardIterator</span>
<span id="L1020"><span class="lineNum">    1020</span>              :     uninitialized_value_construct_n(_ForwardIterator __first, _Size __count)</span>
<span id="L1021"><span class="lineNum">    1021</span>              :     {</span>
<span id="L1022"><span class="lineNum">    1022</span>              :       return __uninitialized_default_n(__first, __count);</span>
<span id="L1023"><span class="lineNum">    1023</span>              :     }</span>
<span id="L1024"><span class="lineNum">    1024</span>              : </span>
<span id="L1025"><span class="lineNum">    1025</span>              :   /**</span>
<span id="L1026"><span class="lineNum">    1026</span>              :    *  @brief Move-construct from the range [first,last) into result.</span>
<span id="L1027"><span class="lineNum">    1027</span>              :    *  @param  __first  An input iterator.</span>
<span id="L1028"><span class="lineNum">    1028</span>              :    *  @param  __last   An input iterator.</span>
<span id="L1029"><span class="lineNum">    1029</span>              :    *  @param  __result An output iterator.</span>
<span id="L1030"><span class="lineNum">    1030</span>              :    *  @return   __result + (__first - __last)</span>
<span id="L1031"><span class="lineNum">    1031</span>              :    *  @since C++17</span>
<span id="L1032"><span class="lineNum">    1032</span>              :   */</span>
<span id="L1033"><span class="lineNum">    1033</span>              :   template &lt;typename _InputIterator, typename _ForwardIterator&gt;</span>
<span id="L1034"><span class="lineNum">    1034</span>              :     inline _ForwardIterator</span>
<span id="L1035"><span class="lineNum">    1035</span>              :     uninitialized_move(_InputIterator __first, _InputIterator __last,</span>
<span id="L1036"><span class="lineNum">    1036</span>              :                        _ForwardIterator __result)</span>
<span id="L1037"><span class="lineNum">    1037</span>              :     {</span>
<span id="L1038"><span class="lineNum">    1038</span>              :       return std::uninitialized_copy</span>
<span id="L1039"><span class="lineNum">    1039</span>              :         (_GLIBCXX_MAKE_MOVE_ITERATOR(__first),</span>
<span id="L1040"><span class="lineNum">    1040</span>              :          _GLIBCXX_MAKE_MOVE_ITERATOR(__last), __result);</span>
<span id="L1041"><span class="lineNum">    1041</span>              :     }</span>
<span id="L1042"><span class="lineNum">    1042</span>              : </span>
<span id="L1043"><span class="lineNum">    1043</span>              :   /**</span>
<span id="L1044"><span class="lineNum">    1044</span>              :    *  @brief Move-construct from the range [first,first+count) into result.</span>
<span id="L1045"><span class="lineNum">    1045</span>              :    *  @param  __first  An input iterator.</span>
<span id="L1046"><span class="lineNum">    1046</span>              :    *  @param  __count  The number of objects to initialize.</span>
<span id="L1047"><span class="lineNum">    1047</span>              :    *  @param  __result An output iterator.</span>
<span id="L1048"><span class="lineNum">    1048</span>              :    *  @return  __result + __count</span>
<span id="L1049"><span class="lineNum">    1049</span>              :    *  @since C++17</span>
<span id="L1050"><span class="lineNum">    1050</span>              :   */</span>
<span id="L1051"><span class="lineNum">    1051</span>              :   template &lt;typename _InputIterator, typename _Size, typename _ForwardIterator&gt;</span>
<span id="L1052"><span class="lineNum">    1052</span>              :     inline pair&lt;_InputIterator, _ForwardIterator&gt;</span>
<span id="L1053"><span class="lineNum">    1053</span>              :     uninitialized_move_n(_InputIterator __first, _Size __count,</span>
<span id="L1054"><span class="lineNum">    1054</span>              :                          _ForwardIterator __result)</span>
<span id="L1055"><span class="lineNum">    1055</span>              :     {</span>
<span id="L1056"><span class="lineNum">    1056</span>              :       auto __res = std::__uninitialized_copy_n_pair</span>
<span id="L1057"><span class="lineNum">    1057</span>              :         (_GLIBCXX_MAKE_MOVE_ITERATOR(__first),</span>
<span id="L1058"><span class="lineNum">    1058</span>              :          __count, __result);</span>
<span id="L1059"><span class="lineNum">    1059</span>              :       return {__res.first.base(), __res.second};</span>
<span id="L1060"><span class="lineNum">    1060</span>              :     }</span>
<span id="L1061"><span class="lineNum">    1061</span>              : #endif // C++17</span>
<span id="L1062"><span class="lineNum">    1062</span>              : </span>
<span id="L1063"><span class="lineNum">    1063</span>              : #if __cplusplus &gt;= 201103L</span>
<span id="L1064"><span class="lineNum">    1064</span>              :   /// @cond undocumented</span>
<span id="L1065"><span class="lineNum">    1065</span>              : </span>
<span id="L1066"><span class="lineNum">    1066</span>              :   template&lt;typename _Tp, typename _Up, typename _Allocator&gt;</span>
<span id="L1067"><span class="lineNum">    1067</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L1068"><span class="lineNum">    1068</span>              :     inline void</span>
<span id="L1069"><span class="lineNum">    1069</span> <span class="tlaGNC tlaBgGNC">          46 :     __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig,</span></span>
<span id="L1070"><span class="lineNum">    1070</span>              :                         _Allocator&amp; __alloc)</span>
<span id="L1071"><span class="lineNum">    1071</span>              :     noexcept(noexcept(std::allocator_traits&lt;_Allocator&gt;::construct(__alloc,</span>
<span id="L1072"><span class="lineNum">    1072</span>              :                          __dest, std::move(*__orig)))</span>
<span id="L1073"><span class="lineNum">    1073</span>              :              &amp;&amp; noexcept(std::allocator_traits&lt;_Allocator&gt;::destroy(</span>
<span id="L1074"><span class="lineNum">    1074</span>              :                             __alloc, std::__addressof(*__orig))))</span>
<span id="L1075"><span class="lineNum">    1075</span>              :     {</span>
<span id="L1076"><span class="lineNum">    1076</span>              :       typedef std::allocator_traits&lt;_Allocator&gt; __traits;</span>
<span id="L1077"><span class="lineNum">    1077</span> <span class="tlaGNC">          46 :       __traits::construct(__alloc, __dest, std::move(*__orig));</span></span>
<span id="L1078"><span class="lineNum">    1078</span> <span class="tlaGNC">          46 :       __traits::destroy(__alloc, std::__addressof(*__orig));</span></span>
<span id="L1079"><span class="lineNum">    1079</span> <span class="tlaGNC">          46 :     }</span></span>
<span id="L1080"><span class="lineNum">    1080</span>              : </span>
<span id="L1081"><span class="lineNum">    1081</span>              :   // This class may be specialized for specific types.</span>
<span id="L1082"><span class="lineNum">    1082</span>              :   // Also known as is_trivially_relocatable.</span>
<span id="L1083"><span class="lineNum">    1083</span>              :   template&lt;typename _Tp, typename = void&gt;</span>
<span id="L1084"><span class="lineNum">    1084</span>              :     struct __is_bitwise_relocatable</span>
<span id="L1085"><span class="lineNum">    1085</span>              :     : is_trivial&lt;_Tp&gt; { };</span>
<span id="L1086"><span class="lineNum">    1086</span>              : </span>
<span id="L1087"><span class="lineNum">    1087</span>              :   template &lt;typename _InputIterator, typename _ForwardIterator,</span>
<span id="L1088"><span class="lineNum">    1088</span>              :             typename _Allocator&gt;</span>
<span id="L1089"><span class="lineNum">    1089</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L1090"><span class="lineNum">    1090</span>              :     inline _ForwardIterator</span>
<span id="L1091"><span class="lineNum">    1091</span> <span class="tlaGNC">          26 :     __relocate_a_1(_InputIterator __first, _InputIterator __last,</span></span>
<span id="L1092"><span class="lineNum">    1092</span>              :                    _ForwardIterator __result, _Allocator&amp; __alloc)</span>
<span id="L1093"><span class="lineNum">    1093</span>              :     noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result),</span>
<span id="L1094"><span class="lineNum">    1094</span>              :                                                std::addressof(*__first),</span>
<span id="L1095"><span class="lineNum">    1095</span>              :                                                __alloc)))</span>
<span id="L1096"><span class="lineNum">    1096</span>              :     {</span>
<span id="L1097"><span class="lineNum">    1097</span>              :       typedef typename iterator_traits&lt;_InputIterator&gt;::value_type</span>
<span id="L1098"><span class="lineNum">    1098</span>              :         _ValueType;</span>
<span id="L1099"><span class="lineNum">    1099</span>              :       typedef typename iterator_traits&lt;_ForwardIterator&gt;::value_type</span>
<span id="L1100"><span class="lineNum">    1100</span>              :         _ValueType2;</span>
<span id="L1101"><span class="lineNum">    1101</span>              :       static_assert(std::is_same&lt;_ValueType, _ValueType2&gt;::value,</span>
<span id="L1102"><span class="lineNum">    1102</span>              :           &quot;relocation is only possible for values of the same type&quot;);</span>
<span id="L1103"><span class="lineNum">    1103</span> <span class="tlaGNC">          26 :       _ForwardIterator __cur = __result;</span></span>
<span id="L1104"><span class="lineNum">    1104</span> <span class="tlaGNC">          72 :       for (; __first != __last; ++__first, (void)++__cur)</span></span>
<span id="L1105"><span class="lineNum">    1105</span> <span class="tlaGNC">          46 :         std::__relocate_object_a(std::__addressof(*__cur),</span></span>
<span id="L1106"><span class="lineNum">    1106</span>              :                                  std::__addressof(*__first), __alloc);</span>
<span id="L1107"><span class="lineNum">    1107</span> <span class="tlaGNC">          26 :       return __cur;</span></span>
<span id="L1108"><span class="lineNum">    1108</span>              :     }</span>
<span id="L1109"><span class="lineNum">    1109</span>              : </span>
<span id="L1110"><span class="lineNum">    1110</span>              : #if _GLIBCXX_HOSTED</span>
<span id="L1111"><span class="lineNum">    1111</span>              :   template &lt;typename _Tp, typename _Up&gt;</span>
<span id="L1112"><span class="lineNum">    1112</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L1113"><span class="lineNum">    1113</span>              :     inline __enable_if_t&lt;std::__is_bitwise_relocatable&lt;_Tp&gt;::value, _Tp*&gt;</span>
<span id="L1114"><span class="lineNum">    1114</span>              :     __relocate_a_1(_Tp* __first, _Tp* __last,</span>
<span id="L1115"><span class="lineNum">    1115</span>              :                    _Tp* __result,</span>
<span id="L1116"><span class="lineNum">    1116</span>              :                    [[__maybe_unused__]] allocator&lt;_Up&gt;&amp; __alloc) noexcept</span>
<span id="L1117"><span class="lineNum">    1117</span>              :     {</span>
<span id="L1118"><span class="lineNum">    1118</span>              :       ptrdiff_t __count = __last - __first;</span>
<span id="L1119"><span class="lineNum">    1119</span>              :       if (__count &gt; 0)</span>
<span id="L1120"><span class="lineNum">    1120</span>              :         {</span>
<span id="L1121"><span class="lineNum">    1121</span>              : #ifdef __cpp_lib_is_constant_evaluated</span>
<span id="L1122"><span class="lineNum">    1122</span>              :           if (std::is_constant_evaluated())</span>
<span id="L1123"><span class="lineNum">    1123</span>              :             {</span>
<span id="L1124"><span class="lineNum">    1124</span>              :               // Can't use memmove. Wrap the pointer so that __relocate_a_1</span>
<span id="L1125"><span class="lineNum">    1125</span>              :               // resolves to the non-trivial overload above.</span>
<span id="L1126"><span class="lineNum">    1126</span>              :               __gnu_cxx::__normal_iterator&lt;_Tp*, void&gt; __out(__result);</span>
<span id="L1127"><span class="lineNum">    1127</span>              :               __out = std::__relocate_a_1(__first, __last, __out, __alloc);</span>
<span id="L1128"><span class="lineNum">    1128</span>              :               return __out.base();</span>
<span id="L1129"><span class="lineNum">    1129</span>              :             }</span>
<span id="L1130"><span class="lineNum">    1130</span>              : #endif</span>
<span id="L1131"><span class="lineNum">    1131</span>              :           __builtin_memmove(__result, __first, __count * sizeof(_Tp));</span>
<span id="L1132"><span class="lineNum">    1132</span>              :         }</span>
<span id="L1133"><span class="lineNum">    1133</span>              :       return __result + __count;</span>
<span id="L1134"><span class="lineNum">    1134</span>              :     }</span>
<span id="L1135"><span class="lineNum">    1135</span>              : #endif</span>
<span id="L1136"><span class="lineNum">    1136</span>              : </span>
<span id="L1137"><span class="lineNum">    1137</span>              :   template &lt;typename _InputIterator, typename _ForwardIterator,</span>
<span id="L1138"><span class="lineNum">    1138</span>              :             typename _Allocator&gt;</span>
<span id="L1139"><span class="lineNum">    1139</span>              :     _GLIBCXX20_CONSTEXPR</span>
<span id="L1140"><span class="lineNum">    1140</span>              :     inline _ForwardIterator</span>
<span id="L1141"><span class="lineNum">    1141</span> <span class="tlaGNC">          26 :     __relocate_a(_InputIterator __first, _InputIterator __last,</span></span>
<span id="L1142"><span class="lineNum">    1142</span>              :                  _ForwardIterator __result, _Allocator&amp; __alloc)</span>
<span id="L1143"><span class="lineNum">    1143</span>              :     noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),</span>
<span id="L1144"><span class="lineNum">    1144</span>              :                                      std::__niter_base(__last),</span>
<span id="L1145"><span class="lineNum">    1145</span>              :                                      std::__niter_base(__result), __alloc)))</span>
<span id="L1146"><span class="lineNum">    1146</span>              :     {</span>
<span id="L1147"><span class="lineNum">    1147</span> <span class="tlaGNC">          26 :       return std::__relocate_a_1(std::__niter_base(__first),</span></span>
<span id="L1148"><span class="lineNum">    1148</span>              :                                  std::__niter_base(__last),</span>
<span id="L1149"><span class="lineNum">    1149</span> <span class="tlaGNC">          26 :                                  std::__niter_base(__result), __alloc);</span></span>
<span id="L1150"><span class="lineNum">    1150</span>              :     }</span>
<span id="L1151"><span class="lineNum">    1151</span>              : </span>
<span id="L1152"><span class="lineNum">    1152</span>              :   /// @endcond</span>
<span id="L1153"><span class="lineNum">    1153</span>              : #endif // C++11</span>
<span id="L1154"><span class="lineNum">    1154</span>              : </span>
<span id="L1155"><span class="lineNum">    1155</span>              :   /// @} group memory</span>
<span id="L1156"><span class="lineNum">    1156</span>              : </span>
<span id="L1157"><span class="lineNum">    1157</span>              : _GLIBCXX_END_NAMESPACE_VERSION</span>
<span id="L1158"><span class="lineNum">    1158</span>              : } // namespace</span>
<span id="L1159"><span class="lineNum">    1159</span>              : </span>
<span id="L1160"><span class="lineNum">    1160</span>              : #endif /* _STL_UNINITIALIZED_H */</span>
        </pre>
              </td>
            </tr>
          </table>
          <br>

          <table width="100%" border=0 cellspacing=0 cellpadding=0>
            <tr><td class="ruler"><img src="../../glass.png" width=3 height=3 alt=""></td></tr>
            <tr><td class="versionInfo">Generated by: <a href="https://github.com//linux-test-project/lcov" target="_parent">LCOV version 2.0-1</a></td></tr>
          </table>
          <br>

</body>
</html>
